binary flags

Flags binaires

Avec cette classe, vous pouvez facilement ajouter des drapeaux à vos projets.

Le nombre d'indicateurs que vous pouvez utiliser est limité à l'architecture de votre système, par exemple: 32 drapeaux sur un système 32 bits ou 64 drapeaux sur le système 64 bits. Pour stocker des indicateurs de 64 bits dans une base de données, vous devrez le stocker en tant que bigint non signé dans MySQL ou équivalent dans votre plaque de données.

Ce package est également livré avec un trait que vous pouvez utiliser pour implémenter des drapeaux binaires directement dans votre propre classe.

Installation

Pour installer ce package, exécutez simplement la commande suivante à la racine de votre projet.

 composer require reinder83/binary-flags

Méthodes

Les méthodes suivantes peuvent être utilisées:

set masque (masque int $)

Écraser le masque actuel. Cela peut être passé comme premier argument dans le constructeur.

getmask (): int

Récupérez le masque actuel.

setonModifyCallback (callable $ onmodify)

Définissez une fonction de rappel qui est appelée lorsque le masque change. Cela peut être passé comme deuxième argument dans le constructeur.

getFLAGNames ([int $ mask, [bool $ asArray = false]])

Donnez le (s) nom (s) pour le $mask donné ou le masque actuel lorsqu'il est omis. Lorsque $asArray est true , la méthode renvoie un tableau avec les noms, sinon une chaîne séparée par virgule sera renvoyée (par défaut).

addflag (int $ drapeau)

Ajoute un ou plusieurs drapeaux au masque actuel.

retirerflag (int $ drapeau)

Supprime un ou plusieurs drapeaux du masque actuel.

CheckFlag (int $ drapeau, [bool $ checkall = true]): bool

Vérifiez si les drapeaux donnés sont définis dans le masque actuel. Par défaut, il vérifiera tous les bits dans le drapeau donné. Lorsque vous souhaitez correspondre à l'un des drapeaux donnés set $checkAll sur false .

CheckanyFlag (Masque int $): bool

Depuis: v1.0.1
Pour vous pratique, j'ai ajouté un alias à CheckFlag avec $checkAll set sur false .

count (): int

Depuis: v1.2.0
Renvoie le nombre de drapeaux qui ont été définis.

jSonSerialize (): mixte

Depuis: v1.2.0
Renvoie une valeur qui peut être codée par json_encode () sous la forme de ["mask" => 7] . Vous ne devez pas avoir à appeler cette méthode directement, mais vous pouvez passer l'objet binaryflags à json_encode qui le convertira en '{"mask": 7}'.

Méthodes statiques

Les méthodes statiques suivantes peuvent être utilisées:

getAllFlags (): Array

Depuis: v1.1.0
Renvoyez tous les drapeaux avec leurs noms en tant que tableau, en utilisant leur masque de drapeau comme clé. Cette méthode peut également être surchargée pour renvoyer des noms personnalisés pour les drapeaux, qui seront utilisés par la méthode getFlagNames .

getAllFlagsmask (): int

Depuis: v1.1.0
Retourner le masque de tous les drapeaux ensemble

Itération

Depuis: v1.2.0
Vous pouvez traiter un objet BinaryFlags comme un itérable, où chaque itération renvoie la valeur de bit suivante qui a été définie, y compris sa description (ou le nom de la constante représentant la valeur bit).

Exemple d'utilisation

Ci-dessous quelques exemples de code d'utilisation

Créer des classes

 // example classes which the following examples will refer to
use Reinder83  BinaryFlags  BinaryFlags ;
use Reinder83  BinaryFlags  Bits ;

class ExampleFlags extends BinaryFlags
{
    const FOO = Bits:: BIT_1 ;
    const BAR = Bits:: BIT_2 ;
    const BAZ = Bits:: BIT_3 ;
}

Utilisation simple

 $ exampleFlags = new ExampleFlags ();

// add BAR flag
$ exampleFlags -> addFlag (ExampleFlags:: BAR );

var_export ( $ exampleFlags -> checkFlag (ExampleFlags:: FOO )); 
// false
var_export ( $ exampleFlags -> checkFlag (ExampleFlags:: BAR )); 
// true

// remove BAR flag
$ exampleFlags -> removeFlag (ExampleFlags:: BAR );

var_export ( $ exampleFlags -> checkFlag (ExampleFlags:: BAR )); 
// false 

Utilisation avec plusieurs drapeaux

 $ exampleFlags = new ExampleFlags ();

// add FOO and BAR
$ exampleFlags -> addFlag (ExampleFlags:: FOO | ExampleFlags:: BAR ); 

var_export ( $ exampleFlags -> checkFlag (ExampleFlags:: FOO )); 
// true

var_export ( $ exampleFlags -> checkFlag (ExampleFlags:: FOO | ExampleFlags:: BAZ )); 
// false because BAZ is not set

var_export ( $ exampleFlags -> checkFlag (ExampleFlags:: FOO | ExampleFlags:: BAR )); 
// true because both flags are set

var_export ( $ exampleFlags -> checkFlag (ExampleFlags:: FOO | ExampleFlags:: BAZ , false )); 
// true because one of the flags is set (FOO)

// alias of the above method
var_export ( $ exampleFlags -> checkAnyFlag (ExampleFlags:: FOO | ExampleFlags:: BAZ )); 
// true 

Exemple de noms de drapeaux

Par défaut, les noms de drapeaux sont basés sur les noms constants

 $ exampleFlags = new ExampleFlags ();

$ exampleFlags -> addFlag (ExampleFlags:: FOO | ExampleFlags:: BAR | ExampleFlags:: BAZ );
var_export ( $ exampleFlags -> getFlagNames ());
// 'Foo, Bar, Baz'

// null will force current mask
var_export ( $ exampleFlags -> getFlagNames ( null , true ));
/*
array (
  0 => 'Foo',
  1 => 'Bar',
  2 => 'Baz',
)
*/

// get flag names of given mask
var_export ( $ exampleFlags -> getFlagNames (ExampleFlags:: FOO | ExampleFlags:: BAR ));
// 'Foo, Bar' 

Exemple de noms de drapeau personnalisé

Si vous voulez des noms d'indicateurs personnalisés qui ne sont pas égaux aux noms constants, vous pouvez les remplacer avec getAllFlags()

 class ExampleFlagsWithNames extends BinaryFlags
{
    const FOO = Bits:: BIT_1 ;
    const BAR = Bits:: BIT_2 ;
    const BAZ = Bits:: BIT_3 ;
    
    public static function getAllFlags ()
    {
        return [
            static :: FOO => ' My foo description ' ,
            static :: BAR => ' My bar description ' ,
            static :: BAZ => ' My baz description ' ,
        ];
    }
}

$ exampleFlags = new ExampleFlagsWithNames ();

$ exampleFlags -> addFlag (ExampleFlags:: FOO | ExampleFlags:: BAR | ExampleFlags:: BAZ );

// null will force current mask
var_export ( $ exampleFlags -> getFlagNames ( null , true ));
/*
array (
  0 => 'My foo description',
  1 => 'My bar description',
  2 => 'My baz description',
)
*/ 

Exemple d'utilisation avec des modèles éloquents

 use Illuminate  Database  Eloquent  Model ;

class Test extends Model
{
    private $ flagsObject ;

    /**
     * Retrieve flags
     * @return ExampleFlags
     */
    public function getFlagsAttribute ()
    {
        if ( $ this -> flagsObject === null ) {
            $ this -> flagsObject = new ExampleFlags (
                $ this -> attributes [ ' flags ' ], // set current flags mask
                function ( ExampleFlags $ flags ) { // set callback function
                    // update the flags in this model
                    $ this -> setAttribute ( ' flags ' , $ flags -> getMask ());
                }
            );
        }
        return $ this -> flagsObject ;
    }
}

// retrieve object from DB
$ test = Test:: find ( 1 );

// do binary operations on the flags class as described earlier
$ test -> flags -> checkFlag (ExampleFlag:: FOO );

Soutien

Pour les bogues ou les demandes de fonctionnalités, n'hésitez pas à me contacter ou à soumettre un problème ou une demande de traction. Ou vous pouvez me soutenir en m'achète un café: