Permissions (OMERO (OME Remote Objects) Server)

java.lang.Object
- ome.model.internal.Permissions

All Implemented Interfaces:

Serializable
```
public class Permissions
extends Object
implements Serializable
```
class responsible for storing all Right/Role-based information for entities as well as various flags for the containing Details instance. It is strongly encouraged to not base any code on the implementation of the rights, roles, and flag but rather to rely on the public methods.
In the future, further roles, rights, and flags may be added to this class. This will change the representation in the database, but the simple grant/revoke/isSet logic will remain the same.

See Also:
ticket:180, Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Permissions.Flag` Currently unused.
`static class`	`Permissions.Right` enumeration of granted rights.
`static class`	`Permissions.Role` enumeration of currently active roles.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ANNOTATERESTRICTION`
`static Permissions`	`COLLAB_READLINK` an immutable `Permissions` instance with read and write permissions for group members.
`static Permissions`	`COLLAB_READONLY` an immutable `Permissions` instance with permissions for group members to read other members' data.
`static int`	`DELETERESTRICTION`
`static Permissions`	`DUMMY` Marker object which can be set on objects to show that the Permissions instance given contains no value.
`static int`	`EDITRESTRICTION`
`static Permissions`	`EMPTY` an immutable `Permissions` instance with all `rights` turned off.
`static Permissions`	`GROUP_IMMUTABLE` R_R___ : user and group can only read
`static Permissions`	`GROUP_PRIVATE` RWRW__ : user and group can read and write
`static Permissions`	`GROUP_READABLE` RWR___ : user can read and write, group can read
`static Permissions`	`GROUP_WRITEABLE` RWRWR_ : user and group can read and write, world can read
`static int`	`LINKRESTRICTION`
`static Permissions`	`PRIVATE` an immutable `Permissions` instance with permissions only for the object owner..
`static Permissions`	`PUBLIC` an immutable `Permissions` instance with all `Rights` granted.
`static Permissions`	`READ_ONLY` an immutable `Permissions` instance with all `Permissions.Right.WRITE` rights turned off.
`static Permissions`	`USER_IMMUTABLE` R______ : user and only the user can only read
`static Permissions`	`USER_PRIVATE` RW____ : user and only user can read and write
`static Permissions`	`USER_WRITEABLE` RWR_R_ : all can read, user can write
`static Permissions`	`WORLD_IMMUTABLE` R_R_R_ : all can only read
`static Permissions`	`WORLD_WRITEABLE` RWRWRW : everyone can read and write

Constructor Summary

Constructors
Constructor and Description

Permissions()
simple contructor.

Permissions(Permissions p)
copy constructor.

Constructors
Constructor and Description
`Permissions()` simple contructor.
`Permissions(Permissions p)` copy constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addExtendedRestrictions(Set<String> extendedRestrictions)`
`static int`	`bit(Permissions.Flag flag)` returns the order of the bit representing the given `Permissions.Flag`.
`static int`	`bit(Permissions.Role role, Permissions.Right right)` returns the order of the bit representing the given `Permissions.Role` and `Permissions.Right`.
`String[]`	`copyExtendedRestrictions()` Produce a copy of restrictions for use elsewhere.
`boolean[]`	`copyRestrictions()` Produce a copy of restrictions for use elsewhere.
`void`	`copyRestrictions(boolean[] source, String[] extendedRestrictions)` Safely copy the source array.
`void`	`copyRestrictions(int allow, Set<String> extendedRestrictions)` Copy restrictions based on the integer returned by BasicACLVoter.
`protected long`	`getPerm1()`
`Permissions`	`grant(Permissions.Role role, Permissions.Right... rights)` turns on the `rights` for the given `role`.
`Permissions`	`grantAll(Permissions mask)` takes a permissions instance and ORs it with the current instance.
`boolean`	`identical(Permissions p)` two `Permissions` instances are `identical` if they have the same bit representation.
`static boolean`	`isDisallow(boolean[] restrictions, int restriction)`
`boolean`	`isDisallowAnnotate()`
`boolean`	`isDisallowDelete()`
`boolean`	`isDisallowEdit()`
`boolean`	`isDisallowLink()`
`boolean`	`isGranted(Permissions.Role role, Permissions.Right right)` tests that a given `Permissions.Role` has the given `Permissions.Right`.
`boolean`	`isSet(Permissions.Flag flag)` tests that a given `Permissions.Flag` is set.
`static Permissions`	`parseString(String rwrwrw)`
`Permissions`	`revoke(Permissions.Role role, Permissions.Right... rights)` turns off the `rights` for the given `role`.
`Permissions`	`revokeAll(Permissions mask)` takes a permissions instance and ANDs it with the current instance.
`boolean`	`sameRights(Permissions p)` returns true if two `Permissions` instances have all the same `Permissions.Right` / `Permissions.Role` pairs granted.
`Permissions`	`set(Permissions.Flag flag)` turn a given `Permissions.Flag` on.
`static void`	`setDisallow(boolean[] restrictions, int restriction, boolean disallow)`
`Permissions`	`setDisallowAnnotate(boolean disallowAnnotate)`
`Permissions`	`setDisallowDelete(boolean disallowDelete)`
`Permissions`	`setDisallowEdit(boolean disallowEdit)`
`Permissions`	`setDisallowLink(boolean disallowLink)`
`protected void`	`setPerm1(long value)`
`protected static long`	`singleBitOn(Permissions.Role role, Permissions.Right right)` returns a long with only a single 1 defined by role/right
`protected static long`	`singleBitOut(Permissions.Role role, Permissions.Right right)` returns a long with only a single 0 defined by role/right
`String`	`toString()` produces a String representation of the `Permissions` similar to those on a Unix filesystem.
`Permissions`	`unSet(Permissions.Flag flag)` turn a given `Permissions.Flag` off.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - LINKRESTRICTION
```
public static final int LINKRESTRICTION
```
    See Also:
    Constant Field Values
  - EDITRESTRICTION
```
public static final int EDITRESTRICTION
```
    See Also:
    Constant Field Values
  - DELETERESTRICTION
```
public static final int DELETERESTRICTION
```
    See Also:
    Constant Field Values
  - ANNOTATERESTRICTION
```
public static final int ANNOTATERESTRICTION
```
    See Also:
    Constant Field Values
  - EMPTY
```
public static final Permissions EMPTY
```
    an immutable Permissions instance with all rights turned off.
  - DUMMY
```
public static final Permissions DUMMY
```
    Marker object which can be set on objects to show that the Permissions instance given contains no value.
  - USER_IMMUTABLE
```
public static final Permissions USER_IMMUTABLE
```
    R______ : user and only the user can only read
  - USER_PRIVATE
```
public static final Permissions USER_PRIVATE
```
    RW____ : user and only user can read and write
  - GROUP_READABLE
```
public static final Permissions GROUP_READABLE
```
    RWR___ : user can read and write, group can read
  - GROUP_PRIVATE
```
public static final Permissions GROUP_PRIVATE
```
    RWRW__ : user and group can read and write
  - GROUP_WRITEABLE
```
public static final Permissions GROUP_WRITEABLE
```
    RWRWR_ : user and group can read and write, world can read
  - WORLD_WRITEABLE
```
public static final Permissions WORLD_WRITEABLE
```
    RWRWRW : everyone can read and write
  - USER_WRITEABLE
```
public static final Permissions USER_WRITEABLE
```
    RWR_R_ : all can read, user can write
  - WORLD_IMMUTABLE
```
public static final Permissions WORLD_IMMUTABLE
```
    R_R_R_ : all can only read
  - GROUP_IMMUTABLE
```
public static final Permissions GROUP_IMMUTABLE
```
    R_R___ : user and group can only read
  - READ_ONLY
```
public static final Permissions READ_ONLY
```
    an immutable Permissions instance with all Permissions.Right.WRITE rights turned off. Identical to WORLD_IMMUTABLE
  - PRIVATE
```
public static final Permissions PRIVATE
```
    an immutable Permissions instance with permissions only for the object owner.. Identical to USER_PRIVATE.
    
    See Also:
    ticket:1434
  - COLLAB_READONLY
```
public static final Permissions COLLAB_READONLY
```
    an immutable Permissions instance with permissions for group members to read other members' data. Identical to GROUP_READABLE.
    
    See Also:
    ticket:1434, ticket:1992
  - COLLAB_READLINK
```
public static final Permissions COLLAB_READLINK
```
    an immutable Permissions instance with read and write permissions for group members. Identical to GROUP_PRIVATE.
    
    See Also:
    ticket:1434, ticket:1992
  - PUBLIC
```
public static final Permissions PUBLIC
```
    an immutable Permissions instance with all Rights granted. Identical to WORLD_WRITEABLE
- Constructor Detail
  - Permissions
```
public Permissions()
```
    simple contructor. Will turn on all rights for all roles
  - Permissions
```
public Permissions(Permissions p)
```
    copy constructor. Will create a new Permissions with the same rights as the argument.
- Method Detail
  - isGranted
```
public boolean isGranted(Permissions.Role role,
                Permissions.Right right)
```
    tests that a given Permissions.Role has the given Permissions.Right.
  - isSet
```
public boolean isSet(Permissions.Flag flag)
```
    tests that a given Permissions.Flag is set.
  - bit
```
public static int bit(Permissions.Flag flag)
```
    returns the order of the bit representing the given Permissions.Flag. This is dependent on the internal representation of Permission and should only be used when necessary.
    
    See Also:
    ome.tools.hibernate.SecurityFilter
  - bit
```
public static int bit(Permissions.Role role,
      Permissions.Right right)
```
    returns the order of the bit representing the given Permissions.Role and Permissions.Right. This is dependent on the internal representation of Permissions and should only be used when necessary.
    
    See Also:
    ome.tools.hibernate.SecurityFilter
  - parseString
```
public static Permissions parseString(String rwrwrw)
```
  - isDisallow
```
public static boolean isDisallow(boolean[] restrictions,
                 int restriction)
```
  - isDisallowAnnotate
```
public boolean isDisallowAnnotate()
```
  - isDisallowDelete
```
public boolean isDisallowDelete()
```
  - isDisallowEdit
```
public boolean isDisallowEdit()
```
  - isDisallowLink
```
public boolean isDisallowLink()
```
  - addExtendedRestrictions
```
public void addExtendedRestrictions(Set<String> extendedRestrictions)
```
  - copyRestrictions
```
public boolean[] copyRestrictions()
```
    Produce a copy of restrictions for use elsewhere.
  - copyExtendedRestrictions
```
public String[] copyExtendedRestrictions()
```
    Produce a copy of restrictions for use elsewhere.
  - copyRestrictions
```
public void copyRestrictions(boolean[] source,
                    String[] extendedRestrictions)
```
    Safely copy the source array. If it is null or contains no "true" values, then the restrictions field will remain null.
  - copyRestrictions
```
public void copyRestrictions(int allow,
                    Set<String> extendedRestrictions)
```
    Copy restrictions based on the integer returned by BasicACLVoter.
  - grant
```
public Permissions grant(Permissions.Role role,
                Permissions.Right... rights)
```
    turns on the rights for the given role. Null or empty rights are simply ignored. For example, somePermissions().grant(USER,READ,WRITE,USE); will guarantee that the current user has all rights on this entity.
  - revoke
```
public Permissions revoke(Permissions.Role role,
                 Permissions.Right... rights)
```
    turns off the rights for the given role. Null or empty rights are simply ignored. For example, new Permissions().revoke(WORLD,WRITE,USE); will return a Permissions instance which cannot be altered or linked to by members of WORLD.
  - grantAll
```
public Permissions grantAll(Permissions mask)
```
    takes a permissions instance and ORs it with the current instance. This means that any privileges which have been granted to the argument will also be granted to the current instance. For example, Permissions mask = new Permissions().grant(WORLD,READ); someEntity.getDetails().getPermissions().grantAllk(mask); will allow READ access (and possibly more) to someEntity for members of WORLD.
  - revokeAll
```
public Permissions revokeAll(Permissions mask)
```
    takes a permissions instance and ANDs it with the current instance. This means that any privileges which have been revoked from the argument will also be revoked from the current instance. For example, Permissions mask = new Permissions().revoke(WORLD,READ,WRITE,USE); someEntity.getDetails().getPermissions().applyMask(mask); will disallow all access to someEntity for members of WORLD. This also implies that applyMask can be used to make copies of Permissions. For example, new Permissions().applyMask( somePermissions ); will produce a copy of somePermissions. Note: the logic here is different from Unix UMASKS.
  - set
```
public Permissions set(Permissions.Flag flag)
```
    turn a given Permissions.Flag on. A null Permissions.Flag will be ignored.
  - unSet
```
public Permissions unSet(Permissions.Flag flag)
```
    turn a given Permissions.Flag off. A null Permissions.Flag will be ignored.
  - setDisallow
```
public static void setDisallow(boolean[] restrictions,
               int restriction,
               boolean disallow)
```
  - setDisallowAnnotate
```
public Permissions setDisallowAnnotate(boolean disallowAnnotate)
```
  - setDisallowDelete
```
public Permissions setDisallowDelete(boolean disallowDelete)
```
  - setDisallowEdit
```
public Permissions setDisallowEdit(boolean disallowEdit)
```
  - setDisallowLink
```
public Permissions setDisallowLink(boolean disallowLink)
```
  - toString
```
public String toString()
```
    produces a String representation of the Permissions similar to those on a Unix filesystem. Unset bits are represented by a dash, while other bits are represented by a symbolic value in the correct bit position. For example, a Permissions with all rights granted to all but WORLD roles would look like: rwrw--
    
    Overrides:
    
    toString in class Object
  - sameRights
```
public boolean sameRights(Permissions p)
```
    returns true if two Permissions instances have all the same Permissions.Right / Permissions.Role pairs granted.
  - identical
```
public boolean identical(Permissions p)
```
    two Permissions instances are identical if they have the same bit representation.
    
    See Also:
    ticket:291
  - getPerm1
```
protected long getPerm1()
```
  - setPerm1
```
protected void setPerm1(long value)
```
  - singleBitOut
```
protected static final long singleBitOut(Permissions.Role role,
                Permissions.Right right)
```
    returns a long with only a single 0 defined by role/right
  - singleBitOn
```
protected static final long singleBitOn(Permissions.Role role,
               Permissions.Right right)
```
    returns a long with only a single 1 defined by role/right

Class Permissions

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LINKRESTRICTION

EDITRESTRICTION

DELETERESTRICTION

ANNOTATERESTRICTION

EMPTY

DUMMY

USER_IMMUTABLE

USER_PRIVATE

GROUP_READABLE

GROUP_PRIVATE

GROUP_WRITEABLE

WORLD_WRITEABLE

USER_WRITEABLE

WORLD_IMMUTABLE

GROUP_IMMUTABLE

READ_ONLY

PRIVATE

COLLAB_READONLY

COLLAB_READLINK

PUBLIC

Constructor Detail

Permissions

Permissions

Method Detail

isGranted

isSet

bit

bit

parseString

isDisallow

isDisallowAnnotate

isDisallowDelete

isDisallowEdit

isDisallowLink

addExtendedRestrictions

copyRestrictions

copyExtendedRestrictions

copyRestrictions

copyRestrictions

grant

revoke

grantAll

revokeAll

set

unSet

setDisallow

setDisallowAnnotate

setDisallowDelete

setDisallowEdit

setDisallowLink

toString

sameRights

identical

getPerm1

setPerm1

singleBitOut

singleBitOn