/*
* Copyright (C) 2015-2016 University of Dundee & Open Microscopy Environment.
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
package omero.gateway.util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.SetMultimap;
import omero.RLong;
import omero.cmd.Chgrp2;
import omero.cmd.Chmod2;
import omero.cmd.Chown2;
import omero.cmd.Delete2;
import omero.cmd.DiskUsage;
import omero.cmd.Duplicate;
import omero.cmd.GraphModify2;
import omero.cmd.SkipHead;
import omero.cmd.graphs.ChildOption;
import omero.model.Experimenter;
import omero.model.ExperimenterGroup;
import omero.model.IObject;
/**
* A utility class of factory methods with various signatures for clients to use in generating requests for graph operations.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.1.0
*/
public class Requests {
/**
* Create a new {@link ChildOption} instance.
* @param includeType the child type to include in the request's operation
* @param excludeType the child type to exclude from the request's operation
* @return the new instance
* @deprecated use {@link Requests.ChildOptionBuilder} from {@link #option()}, see this method for an example
*/
@Deprecated
public static ChildOption option(String includeType, String excludeType) {
ChildOptionBuilder builder = option();
if (includeType != null) {
builder = builder.includeType(includeType);
}
if (excludeType != null) {
builder = builder.excludeType(excludeType);
}
return builder.build();
}
/**
* Create a new {@link ChildOption} instance.
* @param includeType the child types to include in the request's operation
* @param excludeType the child types to exclude from the request's operation
* @return the new instance
* @deprecated use {@link Requests.ChildOptionBuilder} from {@link #option()}, see this method for an example
*/
@Deprecated
public static ChildOption option(List<String> includeType, List<String> excludeType) {
ChildOptionBuilder builder = option();
if (includeType != null) {
builder = builder.includeType(includeType);
}
if (excludeType != null) {
builder = builder.excludeType(excludeType);
}
return builder.build();
}
/**
* Create a new {@link ChildOption} instance.
* @param includeType the child type to include in the request's operation
* @param excludeType the child type to exclude from the request's operation
* @param includeNs the annotation namespace to which this option applies
* @param excludeNs the annotation namespace to which this option does not apply
* @return the new instance
* @deprecated use {@link Requests.ChildOptionBuilder} from {@link #option()}, see this method for an example
*/
@Deprecated
public static ChildOption option(String includeType, String excludeType, String includeNs, String excludeNs) {
ChildOptionBuilder builder = option();
if (includeType != null) {
builder = builder.includeType(includeType);
}
if (excludeType != null) {
builder = builder.excludeType(excludeType);
}
if (includeNs != null) {
builder = builder.includeNs(includeNs);
}
if (excludeNs != null) {
builder = builder.excludeNs(excludeNs);
}
return builder.build();
}
/**
* Create a new {@link ChildOption} instance.
* @param includeType the child type to include in the request's operation
* @param excludeType the child type to exclude from the request's operation
* @param includeNs the annotation namespaces to which this option applies
* @param excludeNs the annotation namespaces to which this option does not apply
* @return the new instance
* @deprecated use {@link Requests.ChildOptionBuilder} from {@link #option()}, see this method for an example
*/
@Deprecated
public static ChildOption option(String includeType, String excludeType, List<String> includeNs,
List<String> excludeNs) {
ChildOptionBuilder builder = option();
if (includeType != null) {
builder = builder.includeType(includeType);
}
if (excludeType != null) {
builder = builder.excludeType(excludeType);
}
if (includeNs != null) {
builder = builder.includeNs(includeNs);
}
if (excludeNs != null) {
builder = builder.excludeNs(excludeNs);
}
return builder.build();
}
/**
* Create a new {@link ChildOption} instance.
* @param includeType the child types to include in the request's operation
* @param excludeType the child types to exclude from the request's operation
* @param includeNs the annotation namespace to which this option applies
* @param excludeNs the annotation namespace to which this option does not apply
* @return the new instance
* @deprecated use {@link Requests.ChildOptionBuilder} from {@link #option()}, see this method for an example
*/
@Deprecated
public static ChildOption option(List<String> includeType, List<String> excludeType, String includeNs, String excludeNs) {
ChildOptionBuilder builder = option();
if (includeType != null) {
builder = builder.includeType(includeType);
}
if (excludeType != null) {
builder = builder.excludeType(excludeType);
}
if (includeNs != null) {
builder = builder.includeNs(includeNs);
}
if (excludeNs != null) {
builder = builder.excludeNs(excludeNs);
}
return builder.build();
}
/**
* Create a new {@link ChildOption} instance.
* @param includeType the child types to include in the request's operation
* @param excludeType the child types to exclude from the request's operation
* @param includeNs the annotation namespaces to which this option applies
* @param excludeNs the annotation namespaces to which this option does not apply
* @return the new instance
* @deprecated use {@link Requests.ChildOptionBuilder} from {@link #option()}, see this method for an example
*/
@Deprecated
public static ChildOption option(List<String> includeType, List<String> excludeType, List<String> includeNs,
List<String> excludeNs) {
ChildOptionBuilder builder = option();
if (includeType != null) {
builder = builder.includeType(includeType);
}
if (excludeType != null) {
builder = builder.excludeType(excludeType);
}
if (includeNs != null) {
builder = builder.includeNs(includeNs);
}
if (excludeNs != null) {
builder = builder.excludeNs(excludeNs);
}
return builder.build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, Long targetId, long groupId) {
return chgrp().target(targetClass).id(targetId).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, Long targetId, ChildOption childOption, long groupId) {
return chgrp().target(targetClass).id(targetId).option(childOption).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, Long targetId, List<ChildOption> childOptions, long groupId) {
return chgrp().target(targetClass).id(targetId).option(childOptions).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param dryRun if this request is a dry run
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, Long targetId, boolean dryRun, long groupId) {
return chgrp().target(targetClass).id(targetId).dryRun(dryRun).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, Long targetId, ChildOption childOption, boolean dryRun, long groupId) {
return chgrp().target(targetClass).id(targetId).option(childOption).dryRun(dryRun).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, Long targetId, List<ChildOption> childOptions, boolean dryRun, long groupId) {
return chgrp().target(targetClass).id(targetId).option(childOptions).dryRun(dryRun).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, List<Long> targetIds, long groupId) {
return chgrp().target(targetClass).id(targetIds).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, List<Long> targetIds, ChildOption childOption, long groupId) {
return chgrp().target(targetClass).id(targetIds).option(childOption).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, long groupId) {
return chgrp().target(targetClass).id(targetIds).option(childOptions).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param dryRun if this request is a dry run
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, List<Long> targetIds, boolean dryRun, long groupId) {
return chgrp().target(targetClass).id(targetIds).dryRun(dryRun).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, List<Long> targetIds, ChildOption childOption, boolean dryRun, long groupId) {
return chgrp().target(targetClass).id(targetIds).option(childOption).dryRun(dryRun).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, boolean dryRun,
long groupId) {
return chgrp().target(targetClass).id(targetIds).option(childOptions).dryRun(dryRun).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetObjects the target objects
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(Map<String, List<Long>> targetObjects, long groupId) {
return chgrp().target(targetObjects).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(Map<String, List<Long>> targetObjects, ChildOption childOption, long groupId) {
return chgrp().target(targetObjects).option(childOption).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, long groupId) {
return chgrp().target(targetObjects).option(childOptions).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetObjects the target objects
* @param dryRun if this request is a dry run
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(Map<String, List<Long>> targetObjects, boolean dryRun, long groupId) {
return chgrp().target(targetObjects).dryRun(dryRun).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(Map<String, List<Long>> targetObjects, ChildOption childOption, boolean dryRun, long groupId) {
return chgrp().target(targetObjects).option(childOption).dryRun(dryRun).toGroup(groupId).build();
}
/**
* Create a new {@link Chgrp2} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param groupId the destination group ID
* @return the new request
* @deprecated use {@link Requests.Chgrp2Builder} from {@link #chgrp()}, see this method for an example
*/
@Deprecated
public static Chgrp2 chgrp(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, boolean dryRun,
long groupId) {
return chgrp().target(targetObjects).option(childOptions).dryRun(dryRun).toGroup(groupId).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, Long targetId, String permissions) {
return chmod().target(targetClass).id(targetId).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, Long targetId, ChildOption childOption, String permissions) {
return chmod().target(targetClass).id(targetId).option(childOption).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, Long targetId, List<ChildOption> childOptions, String permissions) {
return chmod().target(targetClass).id(targetId).option(childOptions).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param dryRun if this request is a dry run
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, Long targetId, boolean dryRun, String permissions) {
return chmod().target(targetClass).id(targetId).dryRun(dryRun).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, Long targetId, ChildOption childOption, boolean dryRun, String permissions) {
return chmod().target(targetClass).id(targetId).option(childOption).dryRun(dryRun).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, Long targetId, List<ChildOption> childOptions, boolean dryRun,
String permissions) {
return chmod().target(targetClass).id(targetId).option(childOptions).dryRun(dryRun).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, List<Long> targetIds, String permissions) {
return chmod().target(targetClass).id(targetIds).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, List<Long> targetIds, ChildOption childOption, String permissions) {
return chmod().target(targetClass).id(targetIds).option(childOption).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, String permissions) {
return chmod().target(targetClass).id(targetIds).option(childOptions).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param dryRun if this request is a dry run
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, List<Long> targetIds, boolean dryRun, String permissions) {
return chmod().target(targetClass).id(targetIds).dryRun(dryRun).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, List<Long> targetIds, ChildOption childOption, boolean dryRun,
String permissions) {
return chmod().target(targetClass).id(targetIds).option(childOption).dryRun(dryRun).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, boolean dryRun,
String permissions) {
return chmod().target(targetClass).id(targetIds).option(childOptions).dryRun(dryRun).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetObjects the target objects
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(Map<String, List<Long>> targetObjects, String permissions) {
return chmod().target(targetObjects).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(Map<String, List<Long>> targetObjects, ChildOption childOption, String permissions) {
return chmod().target(targetObjects).option(childOption).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, String permissions) {
return chmod().target(targetObjects).option(childOptions).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetObjects the target objects
* @param dryRun if this request is a dry run
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(Map<String, List<Long>> targetObjects, boolean dryRun, String permissions) {
return chmod().target(targetObjects).dryRun(dryRun).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(Map<String, List<Long>> targetObjects, ChildOption childOption, boolean dryRun, String permissions) {
return chmod().target(targetObjects).option(childOption).dryRun(dryRun).toPerms(permissions).build();
}
/**
* Create a new {@link Chmod2} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param permissions the new permissions
* @return the new request
* @deprecated use {@link Requests.Chmod2Builder} from {@link #chmod()}, see this method for an example
*/
@Deprecated
public static Chmod2 chmod(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, boolean dryRun,
String permissions) {
return chmod().target(targetObjects).option(childOptions).dryRun(dryRun).toPerms(permissions).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, Long targetId, long userId) {
return chown().target(targetClass).id(targetId).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, Long targetId, ChildOption childOption, long userId) {
return chown().target(targetClass).id(targetId).option(childOption).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, Long targetId, List<ChildOption> childOptions, long userId) {
return chown().target(targetClass).id(targetId).option(childOptions).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param dryRun if this request is a dry run
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, Long targetId, boolean dryRun, long userId) {
return chown().target(targetClass).id(targetId).dryRun(dryRun).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, Long targetId, ChildOption childOption, boolean dryRun, long userId) {
return chown().target(targetClass).id(targetId).option(childOption).dryRun(dryRun).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, Long targetId, List<ChildOption> childOptions, boolean dryRun, long userId) {
return chown().target(targetClass).id(targetId).option(childOptions).dryRun(dryRun).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, List<Long> targetIds, long userId) {
return chown().target(targetClass).id(targetIds).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, List<Long> targetIds, ChildOption childOption, long userId) {
return chown().target(targetClass).id(targetIds).option(childOption).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, long userId) {
return chown().target(targetClass).id(targetIds).option(childOptions).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param dryRun if this request is a dry run
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, List<Long> targetIds, boolean dryRun, long userId) {
return chown().target(targetClass).id(targetIds).dryRun(dryRun).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, List<Long> targetIds, ChildOption childOption, boolean dryRun, long userId) {
return chown().target(targetClass).id(targetIds).option(childOption).dryRun(dryRun).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, boolean dryRun,
long userId) {
return chown().target(targetClass).id(targetIds).option(childOptions).dryRun(dryRun).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetObjects the target objects
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(Map<String, List<Long>> targetObjects, long userId) {
return chown().target(targetObjects).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(Map<String, List<Long>> targetObjects, ChildOption childOption, long userId) {
return chown().target(targetObjects).option(childOption).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, long userId) {
return chown().target(targetObjects).option(childOptions).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetObjects the target objects
* @param dryRun if this request is a dry run
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(Map<String, List<Long>> targetObjects, boolean dryRun, long userId) {
return chown().target(targetObjects).dryRun(dryRun).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(Map<String, List<Long>> targetObjects, ChildOption childOption, boolean dryRun, long userId) {
return chown().target(targetObjects).option(childOption).dryRun(dryRun).toUser(userId).build();
}
/**
* Create a new {@link Chown2} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param userId the destination user ID
* @return the new request
* @deprecated use {@link Requests.Chown2Builder} from {@link #chown()}, see this method for an example
*/
@Deprecated
public static Chown2 chown(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, boolean dryRun,
long userId) {
return chown().target(targetObjects).option(childOptions).dryRun(dryRun).toUser(userId).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, Long targetId) {
return delete().target(targetClass).id(targetId).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, Long targetId, ChildOption childOption) {
return delete().target(targetClass).id(targetId).option(childOption).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, Long targetId, List<ChildOption> childOptions) {
return delete().target(targetClass).id(targetId).option(childOptions).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param dryRun if this request is a dry run
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, Long targetId, boolean dryRun) {
return delete().target(targetClass).id(targetId).dryRun(dryRun).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, Long targetId, ChildOption childOption, boolean dryRun) {
return delete().target(targetClass).id(targetId).option(childOption).dryRun(dryRun).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, Long targetId, List<ChildOption> childOptions, boolean dryRun) {
return delete().target(targetClass).id(targetId).option(childOptions).dryRun(dryRun).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, List<Long> targetIds) {
return delete().target(targetClass).id(targetIds).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, List<Long> targetIds, ChildOption childOption) {
return delete().target(targetClass).id(targetIds).option(childOption).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, List<Long> targetIds, List<ChildOption> childOptions) {
return delete().target(targetClass).id(targetIds).option(childOptions).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param dryRun if this request is a dry run
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, List<Long> targetIds, boolean dryRun) {
return delete().target(targetClass).id(targetIds).dryRun(dryRun).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, List<Long> targetIds, ChildOption childOption, boolean dryRun) {
return delete().target(targetClass).id(targetIds).option(childOption).dryRun(dryRun).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, boolean dryRun) {
return delete().target(targetClass).id(targetIds).option(childOptions).dryRun(dryRun).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetObjects the target objects
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(Map<String, List<Long>> targetObjects) {
return delete().target(targetObjects).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(Map<String, List<Long>> targetObjects, ChildOption childOption) {
return delete().target(targetObjects).option(childOption).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions) {
return delete().target(targetObjects).option(childOptions).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetObjects the target objects
* @param dryRun if this request is a dry run
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(Map<String, List<Long>> targetObjects, boolean dryRun) {
return delete().target(targetObjects).dryRun(dryRun).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(Map<String, List<Long>> targetObjects, ChildOption childOption, boolean dryRun) {
return delete().target(targetObjects).option(childOption).dryRun(dryRun).build();
}
/**
* Create a new {@link Delete2} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @return the new request
* @deprecated use {@link Requests.Delete2Builder} from {@link #delete()}, see this method for an example
*/
@Deprecated
public static Delete2 delete(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, boolean dryRun) {
return delete().target(targetObjects).option(childOptions).dryRun(dryRun).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, String startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, ChildOption childOption, String startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).option(childOption).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, List<ChildOption> childOptions, String startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).option(childOptions).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param dryRun if this request is a dry run
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, boolean dryRun, String startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, ChildOption childOption, boolean dryRun, String startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).option(childOption).dryRun(dryRun)
.startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, List<ChildOption> childOptions, boolean dryRun,
String startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).option(childOptions).dryRun(dryRun)
.startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, ChildOption childOption, List<String> startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).option(childOption).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, List<ChildOption> childOptions, List<String> startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).option(childOptions).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param dryRun if this request is a dry run
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, boolean dryRun, List<String> startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, ChildOption childOption, boolean dryRun,
List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).option(childOption).dryRun(dryRun)
.startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetId the target object ID
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, Long targetId, List<ChildOption> childOptions, boolean dryRun,
List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetId).option(childOptions).dryRun(dryRun)
.startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, String startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, ChildOption childOption, String startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).option(childOption).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, String startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).option(childOptions).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param dryRun if this request is a dry run
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, boolean dryRun, String startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, ChildOption childOption, boolean dryRun,
String startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).option(childOption).dryRun(dryRun)
.startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, boolean dryRun,
String startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).option(childOptions).dryRun(dryRun)
.startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, ChildOption childOption, List<String> startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).option(childOption).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, List<ChildOption> childOptions,
List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).option(childOptions).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param dryRun if this request is a dry run
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, boolean dryRun, List<String> startFrom,
GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, ChildOption childOption, boolean dryRun,
List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).option(childOption).dryRun(dryRun)
.startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetClass the target object class
* @param targetIds the target object IDs
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(String targetClass, List<Long> targetIds, List<ChildOption> childOptions, boolean dryRun,
List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetClass).id(targetIds).option(childOptions).dryRun(dryRun)
.startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, String startFrom, GraphModify2 request) {
return skipHead().target(targetObjects).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, ChildOption childOption, String startFrom,
GraphModify2 request) {
return skipHead().target(targetObjects).option(childOption).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, String startFrom,
GraphModify2 request) {
return skipHead().target(targetObjects).option(childOptions).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param dryRun if this request is a dry run
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, boolean dryRun, String startFrom, GraphModify2 request) {
return skipHead().target(targetObjects).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, ChildOption childOption, boolean dryRun,
String startFrom, GraphModify2 request) {
return skipHead().target(targetObjects).option(childOption).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the class from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, boolean dryRun,
String startFrom, GraphModify2 request) {
return skipHead().target(targetObjects).option(childOptions).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetObjects).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, ChildOption childOption, List<String> startFrom,
GraphModify2 request) {
return skipHead().target(targetObjects).option(childOption).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, List<String> startFrom,
GraphModify2 request) {
return skipHead().target(targetObjects).option(childOptions).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param dryRun if this request is a dry run
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, boolean dryRun, List<String> startFrom,
GraphModify2 request) {
return skipHead().target(targetObjects).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param childOption how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, ChildOption childOption, boolean dryRun,
List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetObjects).option(childOption).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* Create a new {@link SkipHead} request.
* @param targetObjects the target objects
* @param childOptions how to process child objects
* @param dryRun if this request is a dry run
* @param startFrom the classes from which to start the actual processing
* @param request the processor to use
* @return the new request
* @deprecated use {@link Requests.SkipHeadBuilder} from {@link #skipHead()}, see this method for an example
*/
@Deprecated
public static SkipHead skipHead(Map<String, List<Long>> targetObjects, List<ChildOption> childOptions, boolean dryRun,
List<String> startFrom, GraphModify2 request) {
return skipHead().target(targetObjects).option(childOptions).dryRun(dryRun).startFrom(startFrom).request(request).build();
}
/**
* From a model object class determine its simple name suitable for HQL queries or request arguments.
* @param modelClass a model object class
* @return a good name for that class
*/
private static String getModelClassName(Class<? extends IObject> modelClass) {
if (modelClass != IObject.class) {
while (true) {
/* find a direct subclass of IObject */
final Class<? extends IObject> superclass = modelClass.getSuperclass().asSubclass(IObject.class);
if (superclass == IObject.class) {
break;
}
modelClass = superclass;
}
}
return modelClass.getSimpleName();
}
/**
* A general superclass for the builders.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
* @param <X> the type of object to be built
*/
private static abstract class Builder<X> {
protected X assembly;
/**
* Construct a new builder for the given object.
* @param newAssembly the object to be built
*/
Builder(X newAssembly) {
this.assembly = newAssembly;
}
/**
* Assemble and return the finished object.
* @return the built instance
*/
public X build() {
return assembly;
}
}
/**
* A builder for {@link ChildOption} instances.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
*/
public static class ChildOptionBuilder extends Builder<ChildOption> {
/**
* Instantiate a new {@link ChildOption} and initialize its collection containers.
*/
private ChildOptionBuilder() {
super(new ChildOption());
assembly.includeType = new ArrayList<String>();
assembly.excludeType = new ArrayList<String>();
assembly.includeNs = new ArrayList<String>();
assembly.excludeNs = new ArrayList<String>();
}
/* PROPERTY SETTERS THAT ACT DIRECTLY ON THE INSTANCE BEING ASSEMBLED */
/**
* @param types types of children to include in the operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public ChildOptionBuilder includeType(Iterable<String> types) {
for (final String type : types) {
assembly.includeType.add(type);
}
return this;
}
/**
* @param types types of children to include in the operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public ChildOptionBuilder includeType(@SuppressWarnings("unchecked") Class<? extends IObject>... types) {
for (final Class<? extends IObject> type : types) {
assembly.includeType.add(getModelClassName(type));
}
return this;
}
/**
* @param types types of children to exclude from the operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public ChildOptionBuilder excludeType(Iterable<String> types) {
for (final String type : types) {
assembly.excludeType.add(type);
}
return this;
}
/**
* @param types types of children to exclude from the operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public final ChildOptionBuilder excludeType(@SuppressWarnings("unchecked") Class<? extends IObject>... types) {
for (final Class<? extends IObject> type : types) {
assembly.excludeType.add(getModelClassName(type));
}
return this;
}
/**
* @param namespaces annotation namespaces to which to this option applies, does not overwrite previous calls
* @return this builder, for method chaining
*/
public ChildOptionBuilder includeNs(Iterable<String> namespaces) {
for (final String namespace : namespaces) {
assembly.includeNs.add(namespace);
}
return this;
}
/**
* @param namespaces annotation namespaces to which to this option does not apply, does not overwrite previous calls
* @return this builder, for method chaining
*/
public ChildOptionBuilder excludeNs(Iterable<String> namespaces) {
for (final String namespace : namespaces) {
assembly.excludeNs.add(namespace);
}
return this;
}
/* PROPERTY SETTERS THAT SIMPLY WRAP USAGE OF THE ABOVE SETTERS */
/**
* @param types types of children to include in the operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public ChildOptionBuilder includeType(String... types) {
return includeType(Arrays.asList(types));
}
/**
* @param types types of children to exclude from the operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public ChildOptionBuilder excludeType(String... types) {
return excludeType(Arrays.asList(types));
}
/**
* @param namespaces annotation namespaces to which to this option applies, does not overwrite previous calls
* @return this builder, for method chaining
*/
public ChildOptionBuilder includeNs(String... namespaces) {
return includeNs(Arrays.asList(namespaces));
}
/**
* @param namespaces annotation namespaces to which to this option does not apply, does not overwrite previous calls
* @return this builder, for method chaining
*/
public ChildOptionBuilder excludeNs(String... namespaces) {
return excludeNs(Arrays.asList(namespaces));
}
}
/**
* A builder for {@link GraphModify2} instances.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
* @param <B> the type of the builder
* @param <R> the type of the object to be built
*/
private static abstract class GraphModify2Builder<B extends GraphModify2Builder<B, R>, R extends GraphModify2>
extends Builder<R> {
/*
* The @SuppressWarnings and omitted methods in this class are from Java's painfully primitive type system,
* including lack of proper generics, let alone anything modern like associated type families.
*/
/* the class targeted by calls to the id method */
private String targetObjectClass = null;
/* keep a deduplicated copy of all identified targets to minimize a possibly large argument size */
private SetMultimap<String, Long> allTargets = HashMultimap.create();
/**
* Initialize a new {@link GraphModify2}'s collection containers.
*/
GraphModify2Builder(R assembly) {
super(assembly);
assembly.targetObjects = new HashMap<String, List<Long>>();
assembly.childOptions = new ArrayList<ChildOption>();
}
/**
* Assemble and return the finished object.
* @return the built instance
*/
@Override
public R build() {
assembly.targetObjects.clear();
for (final Map.Entry<String, Collection<Long>> target : allTargets.asMap().entrySet()) {
assembly.targetObjects.put(target.getKey(), new ArrayList<Long>(target.getValue()));
}
return super.build();
}
/* PROPERTY SETTERS THAT ACT DIRECTLY ON THE INSTANCE BEING ASSEMBLED */
/**
* @param targets target objects for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
@SuppressWarnings("unchecked")
public B target(Map<String, ? extends Iterable<Long>> targets) {
for (final Map.Entry<String, ? extends Iterable<Long>> classAndIds : targets.entrySet()) {
allTargets.putAll(classAndIds.getKey(), classAndIds.getValue());
}
return (B) this;
}
/**
* @param targetClass a target object type for this operation, required to then use an {@code id} method
* @return this builder, for method chaining
*/
@SuppressWarnings("unchecked")
public B target(String targetClass) {
targetObjectClass = targetClass;
return (B) this;
}
/**
* @param ids target object IDs for this operation, does not overwrite previous calls
* @return this builder, for method chaining
* @see #target(String)
* @see #target(Class)
*/
@SuppressWarnings("unchecked")
public B id(Iterable<Long> ids) {
if (targetObjectClass == null) {
throw new IllegalStateException("must first use target(String) to set class name");
}
allTargets.putAll(targetObjectClass, ids);
return (B) this;
}
/**
* @param ids target object IDs for this operation, does not overwrite previous calls
* @return this builder, for method chaining
* @see #target(String)
* @see #target(Class)
*/
@SuppressWarnings("unchecked")
public B id(RLong... ids) {
if (targetObjectClass == null) {
throw new IllegalStateException("must first use target(String) to set class name");
}
for (final RLong id : ids) {
allTargets.put(targetObjectClass, id.getValue());
}
return (B) this;
}
/**
* @param targets target objects for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
@SuppressWarnings("unchecked")
public B target(IObject... targets) {
for (final IObject target : targets) {
target(target.getClass()).id(target.getId());
}
return (B) this;
}
/**
* @param options child options for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
@SuppressWarnings("unchecked")
public B option(Iterable<ChildOption> options) {
for (final ChildOption option : options) {
assembly.childOptions.add(option);
}
return (B) this;
}
/**
* @param dryRun if this operation is a dry run, does overwrite previous calls
* @return this builder, for method chaining
*/
@SuppressWarnings("unchecked")
public B dryRun(boolean dryRun) {
assembly.dryRun = dryRun;
return (B) this;
}
/* PROPERTY SETTERS THAT SIMPLY WRAP USAGE OF THE ABOVE SETTERS */
/**
* @param targets target objects for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public B target(Multimap<String, Long> targets) {
return target(targets.asMap());
}
/**
* @param targetClass a target object type for this operation, required to then use an {@code id} method
* @return this builder, for method chaining
*/
public B target(Class<? extends IObject> targetClass) {
return target(getModelClassName(targetClass));
}
/**
* @param ids target object IDs for this operation, does not overwrite previous calls
* @return this builder, for method chaining
* @see #target(String)
* @see #target(Class)
*/
public B id(Long... ids) {
return id(Arrays.asList(ids));
}
/**
* @param options child options for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public B option(ChildOption... options) {
return option(Arrays.asList(options));
}
/**
* Set that this operation is a dry run.
* @return this builder, for method chaining
*/
public B dryRun() {
return dryRun(true);
}
}
/**
* A builder for {@link Chgrp2} instances.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
*/
public static class Chgrp2Builder extends GraphModify2Builder<Chgrp2Builder, Chgrp2> {
/**
* Instantiate a new {@link Chgrp2}.
*/
public Chgrp2Builder() {
super(new Chgrp2());
}
/* PROPERTY SETTERS THAT ACT DIRECTLY ON THE INSTANCE BEING ASSEMBLED */
/**
* @param id the group to which to move the target objects, does overwrite previous calls
* @return this builder, for method chaining
*/
public Chgrp2Builder toGroup(long id) {
assembly.groupId = id;
return this;
}
/* PROPERTY SETTERS THAT SIMPLY WRAP USAGE OF THE ABOVE SETTERS */
/**
* @param id the group to which to move the target objects, does overwrite previous calls
* @return this builder, for method chaining
*/
public Chgrp2Builder toGroup(RLong id) {
return toGroup(id.getValue());
}
/**
* @param group the group to which to move the target objects, does overwrite previous calls
* @return this builder, for method chaining
*/
public Chgrp2Builder toGroup(ExperimenterGroup group) {
return toGroup(group.getId());
}
}
/**
* A builder for {@link Chown2} instances.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
*/
public static class Chown2Builder extends GraphModify2Builder<Chown2Builder, Chown2> {
/**
* Instantiate a new {@link Chown2}.
*/
public Chown2Builder() {
super(new Chown2());
}
/* PROPERTY SETTERS THAT ACT DIRECTLY ON THE INSTANCE BEING ASSEMBLED */
/**
* @param id the user to which to give the target objects, does overwrite previous calls
* @return this builder, for method chaining
*/
public Chown2Builder toUser(long id) {
assembly.userId = id;
return this;
}
/* PROPERTY SETTERS THAT SIMPLY WRAP USAGE OF THE ABOVE SETTERS */
/**
* @param id the user to which to give the target objects, does overwrite previous calls
* @return this builder, for method chaining
*/
public Chown2Builder toUser(RLong id) {
return toUser(id.getValue());
}
/**
* @param user the user to which to give the target objects, does overwrite previous calls
* @return this builder, for method chaining
*/
public Chown2Builder toGroup(Experimenter user) {
return toUser(user.getId());
}
}
/**
* A builder for {@link Chmod2} instances.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
*/
public static class Chmod2Builder extends GraphModify2Builder<Chmod2Builder, Chmod2> {
/**
* Instantiate a new {@link Chmod2}.
*/
public Chmod2Builder() {
super(new Chmod2());
}
/* PROPERTY SETTERS THAT ACT DIRECTLY ON THE INSTANCE BEING ASSEMBLED */
/**
* @param permissions the permissions to which to set the target objects, does overwrite previous calls
* @return this builder, for method chaining
*/
public Chmod2Builder toPerms(String permissions) {
assembly.permissions = permissions;
return this;
}
}
/**
* A builder for {@link Delete2} instances.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
*/
public static class Delete2Builder extends GraphModify2Builder<Delete2Builder, Delete2> {
/**
* Instantiate a new {@link Delete2}.
*/
public Delete2Builder() {
super(new Delete2());
}
}
/**
* A builder for {@link Duplicate} instances.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
*/
public static class DuplicateBuilder extends GraphModify2Builder<DuplicateBuilder, Duplicate> {
/**
* Instantiate a new {@link Duplicate} and initialize its collection containers.
*/
public DuplicateBuilder() {
super(new Duplicate());
assembly.typesToDuplicate = new ArrayList<String>();
assembly.typesToReference = new ArrayList<String>();
assembly.typesToIgnore = new ArrayList<String>();
}
/* PROPERTY SETTERS THAT ACT DIRECTLY ON THE INSTANCE BEING ASSEMBLED */
/**
* @param types types to duplicate, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DuplicateBuilder duplicateType(Iterable<String> types) {
for (final String type : types) {
assembly.typesToDuplicate.add(type);
}
return this;
}
/**
* @param types types to duplicate, does not overwrite previous calls
* @return this builder, for method chaining
*/
public final DuplicateBuilder duplicateType(@SuppressWarnings("unchecked") Class<? extends IObject>... types) {
for (final Class<? extends IObject> type : types) {
assembly.typesToDuplicate.add(getModelClassName(type));
}
return this;
}
/**
* @param types types to reference from duplicates, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DuplicateBuilder referenceType(Iterable<String> types) {
for (final String type : types) {
assembly.typesToReference.add(type);
}
return this;
}
/**
* @param types types to reference from duplicates, does not overwrite previous calls
* @return this builder, for method chaining
*/
public final DuplicateBuilder referenceType(@SuppressWarnings("unchecked") Class<? extends IObject>... types) {
for (final Class<? extends IObject> type : types) {
assembly.typesToReference.add(getModelClassName(type));
}
return this;
}
/**
* @param types types to keep separate from duplicates, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DuplicateBuilder ignoreType(Iterable<String> types) {
for (final String type : types) {
assembly.typesToIgnore.add(type);
}
return this;
}
/**
* @param types types to keep separate from duplicates, does not overwrite previous calls
* @return this builder, for method chaining
*/
public final DuplicateBuilder ignoreType(@SuppressWarnings("unchecked") Class<? extends IObject>... types) {
for (final Class<? extends IObject> type : types) {
assembly.typesToIgnore.add(getModelClassName(type));
}
return this;
}
/* PROPERTY SETTERS THAT SIMPLY WRAP USAGE OF THE ABOVE SETTERS */
/**
* @param types types to duplicate, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DuplicateBuilder duplicateType(String... types) {
return duplicateType(Arrays.asList(types));
}
/**
* @param types types to reference from duplicates, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DuplicateBuilder referenceType(String... types) {
return referenceType(Arrays.asList(types));
}
/**
* @param types types to keep separate from duplicates, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DuplicateBuilder ignoreType(String... types) {
return ignoreType(Arrays.asList(types));
}
}
/**
* A builder for {@link SkipHead} instances.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
*/
public static class SkipHeadBuilder extends GraphModify2Builder<SkipHeadBuilder, SkipHead> {
/**
* Instantiate a new {@link SkipHead} and initialize its collection containers.
*/
public SkipHeadBuilder() {
super(new SkipHead());
assembly.startFrom = new ArrayList<String>();
}
/* PROPERTY SETTERS THAT ACT DIRECTLY ON THE INSTANCE BEING ASSEMBLED */
/**
* @param types types from which to start the operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public SkipHeadBuilder startFrom(Iterable<String> types) {
for (final String type : types) {
assembly.startFrom.add(type);
}
return this;
}
/**
* @param types types from which to start the operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public final SkipHeadBuilder startFrom(@SuppressWarnings("unchecked") Class<? extends IObject>... types) {
for (final Class<? extends IObject> type : types) {
assembly.startFrom.add(getModelClassName(type));
}
return this;
}
/**
* @param request the operation to perform once target objects are identified, does overwrite previous calls
* @return this builder, for method chaining
*/
public final SkipHeadBuilder request(GraphModify2 request) {
assembly.request = request;
return this;
}
/* PROPERTY SETTERS THAT SIMPLY WRAP USAGE OF THE ABOVE SETTERS */
/**
* @param types types from which to start the operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public SkipHeadBuilder startFrom(String... types) {
return startFrom(Arrays.asList(types));
}
/**
* @param request the operation to perform once target objects are identified, does overwrite previous calls
* @return this builder, for method chaining
*/
public final SkipHeadBuilder request(Class<? extends GraphModify2> request) {
try {
return request(request.newInstance());
} catch (ReflectiveOperationException e) {
throw new IllegalArgumentException("invalid request class", e);
}
}
}
/**
* A builder for {@link DiskUsage} instances.
* @author m.t.b.carroll@dundee.ac.uk
* @since 5.2.3
*/
public static class DiskUsageBuilder extends Builder<DiskUsage> {
/* the class targeted by calls to the id method */
private String targetObjectClass = null;
/* keep a deduplicated copy of all identified targets to minimize a possibly large argument size */
private SetMultimap<String, Long> allTargets = HashMultimap.create();
/**
* Instantiate a new {@link DiskUsage} and initialize its collection containers.
*/
DiskUsageBuilder() {
super(new DiskUsage());
assembly.classes = new ArrayList<String>();
assembly.objects = new HashMap<String, List<Long>>();
}
/**
* Assemble and return the finished object.
* @return the built instance
*/
@Override
public DiskUsage build() {
assembly.objects.clear();
for (final Map.Entry<String, Collection<Long>> target : allTargets.asMap().entrySet()) {
assembly.objects.put(target.getKey(), new ArrayList<Long>(target.getValue()));
}
return super.build();
}
/* PROPERTY SETTERS THAT ACT DIRECTLY ON THE INSTANCE BEING ASSEMBLED */
/**
* @param targets target objects for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DiskUsageBuilder target(Map<String, ? extends Iterable<Long>> targets) {
for (final Map.Entry<String, ? extends Iterable<Long>> classAndIds : targets.entrySet()) {
allTargets.putAll(classAndIds.getKey(), classAndIds.getValue());
}
return this;
}
/**
* @param targetClass a target object type for this operation, required to then use an {@code id} method
* @return this builder, for method chaining
*/
public DiskUsageBuilder target(String targetClass) {
targetObjectClass = targetClass;
return this;
}
/**
* @param ids target object IDs for this operation, does not overwrite previous calls
* @return this builder, for method chaining
* @see #target(String)
* @see #target(Class)
*/
public DiskUsageBuilder id(Iterable<Long> ids) {
if (targetObjectClass == null) {
throw new IllegalStateException("must first use target(String) to set class name");
}
allTargets.putAll(targetObjectClass, ids);
return this;
}
/**
* @param ids target object IDs for this operation, does not overwrite previous calls
* @return this builder, for method chaining
* @see #target(String)
* @see #target(Class)
*/
public DiskUsageBuilder id(RLong... ids) {
if (targetObjectClass == null) {
throw new IllegalStateException("must first use target(String) to set class name");
}
for (final RLong id : ids) {
allTargets.put(targetObjectClass, id.getValue());
}
return this;
}
/**
* @param targets target objects for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DiskUsageBuilder target(IObject... targets) {
for (final IObject target : targets) {
target(target.getClass()).id(target.getId());
}
return this;
}
/**
* @param types whole types to target for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DiskUsageBuilder type(Iterable<String> types) {
for (final String type : types) {
assembly.classes.add(type);
}
return this;
}
/**
* @param types whole types to target for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public final DiskUsageBuilder type(@SuppressWarnings("unchecked") Class<? extends IObject>... types) {
for (final Class<? extends IObject> type : types) {
assembly.classes.add(getModelClassName(type));
}
return this;
}
/* PROPERTY SETTERS THAT SIMPLY WRAP USAGE OF THE ABOVE SETTERS */
/**
* @param targets target objects for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DiskUsageBuilder target(Multimap<String, Long> targets) {
return target(targets.asMap());
}
/**
* @param targetClass a target object type for this operation, required to then use an {@code id} method
* @return this builder, for method chaining
*/
public DiskUsageBuilder target(Class<? extends IObject> targetClass) {
return target(getModelClassName(targetClass));
}
/**
* @param ids target object IDs for this operation, does not overwrite previous calls
* @return this builder, for method chaining
* @see #target(String)
* @see #target(Class)
*/
public DiskUsageBuilder id(Long... ids) {
return id(Arrays.asList(ids));
}
/**
* @param types whole types to target for this operation, does not overwrite previous calls
* @return this builder, for method chaining
*/
public DiskUsageBuilder type(String... types) {
return type(Arrays.asList(types));
}
}
/**
* @return a new {@link ChildOption} builder
*/
public static ChildOptionBuilder option() {
return new ChildOptionBuilder();
}
/**
* @return a new {@link Chgrp2} builder
*/
public static Chgrp2Builder chgrp() {
return new Chgrp2Builder();
}
/**
* @return a new {@link Chown2} builder
*/
public static Chown2Builder chown() {
return new Chown2Builder();
}
/**
* @return a new {@link Chmod2} builder
*/
public static Chmod2Builder chmod() {
return new Chmod2Builder();
}
/**
* @return a new {@link Delete2} builder
*/
public static Delete2Builder delete() {
return new Delete2Builder();
}
/**
* @return a new {@link Duplicate} builder
*/
public static DuplicateBuilder duplicate() {
return new DuplicateBuilder();
}
/**
* @return a new {@link SkipHead} builder
*/
public static SkipHeadBuilder skipHead() {
return new SkipHeadBuilder();
}
/**
* @return a new {@link DiskUsage} builder
*/
public static DiskUsageBuilder diskUsage() {
return new DiskUsageBuilder();
}
}