binary flags

Binaryflags

Mit dieser Klasse können Sie Ihren Projekten problemlos Flags hinzufügen.

Die Anzahl der Flags, die Sie verwenden können, ist auf die Architektur Ihres Systems beschränkt, z. B. 32 Flags auf einem 32-Bit-System oder 64 Flags auf 64-Bit-System. Um 64-Bit-Flags in einer Datenbank zu speichern, müssen Sie es als unsigned Bigint in MySQL oder als Äquivalent in Ihrem Datenspeicher speichern.

Dieses Paket enthält außerdem ein Merkmal, mit dem Sie Binärflags direkt in Ihrer eigenen Klasse implementieren können.

Installation

Um dieses Paket zu installieren, führen Sie einfach den folgenden Befehl im Root Ihres Projekts aus.

 composer require reinder83/binary-flags

Methoden

Die folgenden Methoden können verwendet werden:

setmask (int $ mask)

Überschreiben Sie die aktuelle Maske. Dies kann als erster Argument im Konstruktor übergeben werden.

GetMask (): int

Die aktuelle Maske abrufen.

setonModifyCallback (Callable $ onModify)

Legen Sie eine Rückruffunktion fest, die aufgerufen wird, wenn sich die Maske ändert. Dies kann als zweites Argument im Konstruktor übergeben werden.

getflagnames ([int $ mask, [bool $ asarray = false]])

Geben Sie die Namen (en) für die angegebene $mask oder die aktuelle Maske nach weggelassen. Wenn $asArray true ist, gibt die Methode ein Array mit den Namen zurück, da sonst eine von Kommas getrennte Zeichenfolge zurückgegeben wird (Standard).

Addflag (int $ flag)

Fügt der aktuellen Maske eine oder mehrere Flags hinzu.

RemoveFlag (int $ flag)

Entfernt ein oder mehrere Flags aus der aktuellen Maske.

Checkflag (int $ flag, [bool $ checkall = true]): bool

Überprüfen Sie, ob die angegebenen Flaggen in der aktuellen Maske eingestellt sind. Standardmäßig werden alle Bits in der angegebenen Flagge überprüft. Wenn Sie einem der angegebenen Flags übereinstimmen möchten, setzen Sie $checkAll auf false .

checkyFlag (int $ mask): bool

Da: v1.0.1
Für Sie bequem habe ich einen Alias ​​hinzugefügt, um mit $checkAll auf false festgelegt zu werden.

count (): int

Da: v1.2.0
Gibt die Anzahl der festgelegten Flags zurück.

JsonSerialize (): gemischt

Da: v1.2.0
Geben Sie einen Wert zurück, der von json_encode () in Form von ["mask" => 7] codiert werden kann. Sie sollten diese Methode nicht direkt aufrufen, stattdessen können Sie das BinaryFlags -Objekt an JSON_Encode übergeben, das es in '{"mask": 7}' umwandelt.

Statische Methoden

Die folgenden statischen Methoden können verwendet werden:

getAllflags (): Array

Da: v1.1.0
Geben Sie alle Flags mit ihren Namen als Array zurück und verwenden Sie ihre Flag -Maske als Schlüssel. Diese Methode kann auch überladen werden, um benutzerdefinierte Namen für die Flags zurückzugeben, die von der getFlagNames -Methode verwendet werden.

getAllflagsmask (): int

Da: v1.1.0
Rückmaske aller Flaggen gemeinsam

Iteration

Da: v1.2.0
Sie können ein BinaryFlags -Objekt als iterable behandeln, wobei jede Iteration den nächsten Bitwert zurückgibt, der eingestellt wurde, einschließlich ihrer Beschreibung (oder des Namens der Konstante, die den Bitwert darstellt).

Beispiel Verwendung

Unter einigen Beispielnutzungscode

Klassen erstellen

 // 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 ;
}

Einfache Verwendung

 $ 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 

Verwendung mit mehreren Flaggen

 $ 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 

Beispielnamen Beispiel

Standardmäßig basieren die Flag -Namen auf den konstanten Namen

 $ 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' 

Beispiel für benutzerdefinierte Flaggennamen

Wenn Sie benutzerdefinierte Flaggenamen möchten, die nicht den konstanten Namen entsprechen, können Sie diese mit getAllFlags() überschreiben.

 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',
)
*/ 

Beispiel Verwendung mit beredten Modellen

 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 );

Unterstützung

Für Fehler oder Feature -Anfragen können Sie mich gerne kontaktieren oder eine Ausgabe oder eine Anfrage einreichen. Oder Sie können mich unterstützen, indem Sie mir einen Kaffee kaufen: