créer un masque de bits d'autorisation en java

Question

Je veux faire quelque chose comme ceci:

public enum Permissions
{
    CanBlah1,
    CanBlah2,
    CanBlah3
}

byte[] userPerm = Permissions.CanBlah1 | Permissions.CanBlah2;

// check permssions
//
if(userPerm && Permissions.CanBlah1 == Permissions.CanBlah1)
{
      // do something
}

Pouvez-vous faire en Java comme ça? (Je viens d'un milieu c #)

Answer 1

Vous pouvez facilement le faire en utilisant EnumSet

import java.util.EnumSet;

import static java.util.EnumSet.of;
import static java.util.EnumSet.range;
import static so.User.Permissions.CanBlah1;
import static so.User.Permissions.CanBlah2;
import static so.User.Permissions.CanBlah3;

public class User {
    public enum Permissions {
        CanBlah1,
        CanBlah2,
        CanBlah3
    }

    public static void main(String[] args) throws Exception {
        EnumSet<Permissions> userPerms = of(CanBlah1, CanBlah2);
        System.out.println(userPerms.contains(CanBlah1)); //true
        System.out.println(userPerms.contains(CanBlah2)); //true
        System.out.println(userPerms.contains(CanBlah3)); //false
        System.out.println(userPerms.containsAll(of(CanBlah1, CanBlah3))); //false
        System.out.println(userPerms.containsAll(range(CanBlah1, CanBlah2))); //true
        System.out.println(userPerms.containsAll(range(CanBlah1, CanBlah3))); //false
    }

}

Answer 2

Il est une autre option, qui est similaire à la solution ordinale, sauf que vous pouvez utiliser le | et & opérateurs avec ceci:

 public enum Permissions {
     CanBlah1(1),
     CanBlah2(2),
     CanBlah3(4);

     public int value;

     Permissions(int value) {
         this.value = value;
     }
     public int value() {
      return value;
     }
 }

 public static void main(String[] args) {  
    int userPerm = Permissions.CanBlah1.value() | Permissions.CanBlah2.value();
    // check permssions
    //
    if((userPerm & Permissions.CanBlah1.value()) == Permissions.CanBlah1.value())
    {
        // do something
    }
 }

ou

 public enum Permissions {
         CanBlah1,
         CanBlah2,
         CanBlah3;

         public int value() {
            return 1<<ordinal();
         }
     }

     public static void main(String[] args) {  
        int userPerm = Permissions.CanBlah1.value() | Permissions.CanBlah2.value();
        // check permssions
        //
        if((userPerm & Permissions.CanBlah1.value()) == Permissions.CanBlah1.value())
        {
            // do something
        }
     }

Answer 3

Bien que je ne recommanderais pas, vous pouvez demander l'ordinal () d'un ENUM et l'utiliser pour les opérations de bits. Bien sûr, puisque vous ne pouvez pas définir le nombre ordinal pour un ENUM, vous devez insérer des valeurs fausses pour obtenir le droit ordinaux

enum Example {
   Bogus,            --> 0
   This,             --> 1
   That,             --> 2
   ThisOrThat        --> 3
};

Remarquez une ENUM Bogus nécessaire pour introduire de telle sorte que

ThisOrThat.ordinal() == This.ordinal() | That.ordinal()

Answer 4

Si vous coincé dans l'ère pré Java 7 (Android), vous pouvez essayer le code suivant:

public enum STUFF_TO_BIT_BASK {
THIS,THAT,OTHER;

public static int getBitMask(STUFF_TO_BIT_BASK... masks) {
    int res = 0;

    for (STUFF_TO_BIT_BASK cap : masks) {
        res |= (int) Math.pow(2, cap.ordinal());
    }

    return res;
}

public boolean is(int maskToCheck){
    return maskToCheck | (int) Math.pow(2, this.ordinal());
}

}

Answer 5

Pour autant que je sais opérateur est pas défini pour bitwise types enum