RoleDefault.java
/*
* This file is part of Waarp Project (named also Waarp or GG).
*
* Copyright (c) 2019, Waarp SAS, and individual contributors by the @author
* tags. See the COPYRIGHT.txt in the distribution for a full listing of
* individual contributors.
*
* All Waarp Project 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 3 of the License, or (at your
* option) any later version.
*
* Waarp 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
* Waarp . If not, see <http://www.gnu.org/licenses/>.
*/
package org.waarp.common.role;
/**
* Role to be used in Waarp projects
*/
public class RoleDefault {
public enum ROLE {
/**
* No access to any function
*/
NOACCESS(0),
/**
* Read only access, no action
*/
READONLY(1),
/**
* Ability to starts transfer
*/
TRANSFER(2),
/**
* Ability to control rules
*/
RULE(4),
/**
* Ability to control hosts
*/
HOST(8),
/**
* Ability to control bandwidth limitation
*/
LIMIT(16),
/**
* Ability to control the system configuration and to control transfers
*/
SYSTEM(32),
/**
* Ability to control the logging
*/
LOGCONTROL(64),
/**
* Unused Role value
*/
UNUSED(-128),
/**
* Default partner : ability to read and starts transfers
*/
PARTNER(READONLY, TRANSFER),
/**
* Administrator on configuration (partner, rule, host)
*/
CONFIGADMIN(PARTNER, RULE, HOST),
/**
* Administrator on all
*/
FULLADMIN(CONFIGADMIN, LIMIT, SYSTEM, LOGCONTROL);
private byte brole;
ROLE(final int val) {
brole = (byte) val;
}
ROLE(final ROLE... name) {
for (final ROLE role : name) {
this.brole |= role.brole;
}
}
public final boolean isContained(final byte value) {
if (this == NOACCESS) {
return value == NOACCESS.brole;
}
return (value & brole) == brole;
}
public final boolean isContained(final ROLE role) {
return isContained(role.brole);
}
public final boolean contains(final ROLE role) {
return role.isContained(this);
}
public final byte getAsByte() {
return brole;
}
private static final ROLE[] READONLY_A = new ROLE[] { READONLY };
private static final ROLE[] TRANSFER_A = new ROLE[] { TRANSFER };
private static final ROLE[] RULE_A = new ROLE[] { RULE };
private static final ROLE[] HOST_A = new ROLE[] { HOST };
private static final ROLE[] LIMIT_A = new ROLE[] { LIMIT };
private static final ROLE[] SYSTEM_A = new ROLE[] { SYSTEM };
private static final ROLE[] LOGCONTROL_A = new ROLE[] { LOGCONTROL };
private static final ROLE[] UNUSED_A = new ROLE[] { UNUSED };
private static final ROLE[] NOACCESS_A = new ROLE[] { NOACCESS };
private static final ROLE[] PARTNER_A = new ROLE[] { READONLY, TRANSFER };
private static final ROLE[] CONFIGADMIN_A =
new ROLE[] { READONLY, TRANSFER, RULE, HOST };
private static final ROLE[] FULLADMIN_A =
new ROLE[] { READONLY, TRANSFER, RULE, LIMIT, SYSTEM, LOGCONTROL };
public final ROLE[] getComposingRoles() {
switch (brole) {
case 1:
return READONLY_A;
case 2:
return TRANSFER_A;
case 3:
return PARTNER_A;
case 4:
return RULE_A;
case 8:
return HOST_A;
case 15:
return CONFIGADMIN_A;
case 16:
return LIMIT_A;
case 32:
return SYSTEM_A;
case 64:
return LOGCONTROL_A;
case 127:
return FULLADMIN_A;
case -128:
return UNUSED_A;
case 0:
default:
return NOACCESS_A;
}
}
public static String toString(final byte fromRole) {
final StringBuilder result = new StringBuilder("[ ");
final ROLE[] values = ROLE.values();
for (final ROLE role : values) {
if (role.isContained(fromRole)) {
result.append(role.name()).append(' ');
}
}
result.append(']');
return result.toString();
}
public static ROLE fromByte(final byte role) {
switch (role) {
case 1:
return READONLY;
case 2:
return TRANSFER;
case 3:
return PARTNER;
case 4:
return RULE;
case 8:
return HOST;
case 15:
return CONFIGADMIN;
case 16:
return LIMIT;
case 32:
return SYSTEM;
case 64:
return LOGCONTROL;
case 127:
return FULLADMIN;
case -128:
return UNUSED;
case 0:
default:
return NOACCESS;
}
}
}
private byte role;
public RoleDefault() {
role = ROLE.NOACCESS.brole;
}
public RoleDefault(final ROLE role) {
this.role = role.brole;
}
public final byte getRoleAsByte() {
return role;
}
@Override
public String toString() {
return ROLE.toString(role);
}
public final RoleDefault addRole(final ROLE newrole) {
role |= newrole.brole;
return this;
}
public final RoleDefault setRole(final ROLE newrole) {
role = newrole.brole;
return this;
}
public final RoleDefault setRoleDefault(final RoleDefault newrole) {
role = newrole.role;
return this;
}
public final void clear() {
role = ROLE.NOACCESS.brole;
}
public final boolean isContaining(final ROLE otherrole) {
return otherrole.isContained(role);
}
public final boolean hasNoAccess() {
return role == ROLE.NOACCESS.brole;
}
public final boolean hasReadOnly() {
return ROLE.READONLY.isContained(role);
}
public final boolean hasTransfer() {
return ROLE.TRANSFER.isContained(role);
}
public final boolean hasRule() {
return ROLE.RULE.isContained(role);
}
public final boolean hasHost() {
return ROLE.HOST.isContained(role);
}
public final boolean hasLimit() {
return ROLE.LIMIT.isContained(role);
}
public final boolean hasSystem() {
return ROLE.SYSTEM.isContained(role);
}
public final boolean hasUnused() {
return ROLE.UNUSED.isContained(role);
}
public final boolean hasLogControl() {
return ROLE.LOGCONTROL.isContained(role);
}
public static boolean hasNoAccess(final byte role) {
return role == ROLE.NOACCESS.brole;
}
public static boolean hasReadOnly(final byte role) {
return ROLE.READONLY.isContained(role);
}
public static boolean hasTransfer(final byte role) {
return ROLE.TRANSFER.isContained(role);
}
public static boolean hasRule(final byte role) {
return ROLE.RULE.isContained(role);
}
public static boolean hasHost(final byte role) {
return ROLE.HOST.isContained(role);
}
public static boolean hasLimit(final byte role) {
return ROLE.LIMIT.isContained(role);
}
public static boolean hasSystem(final byte role) {
return ROLE.SYSTEM.isContained(role);
}
public static boolean hasUnused(final byte role) {
return ROLE.UNUSED.isContained(role);
}
public static boolean hasLogControl(final byte role) {
return ROLE.LOGCONTROL.isContained(role);
}
}