Descarga binary flags - Descarga del código fuente binary flags

binary flags

Otras categorias

Maintenance release PHP 8+

Descargar

Binarios

Con esta clase puede agregar fácilmente banderas a sus proyectos.

El número de banderas que puede usar se limita a la arquitectura de su sistema, por ejemplo, 32 banderas en un sistema de 32 bits o 64 banderas en el sistema de 64 bits. Para almacenar banderas de 64 bits en una base de datos, deberá almacenarlo como Bigint sin firmar en MySQL o como equivalente en su almacén de datos.

Este paquete también viene con un rasgo que puede usar para implementar banderas binarias directamente en su propia clase.

Instalación

Para instalar este paquete, simplemente ejecute el siguiente comando en la raíz de su proyecto.

 composer require reinder83/binary-flags

Métodos

Se pueden usar los siguientes métodos:

SetMask (int $ Mask)

Sobrescribe la máscara actual. Esto puede aprobarse como primer argumento en el constructor.

getMask (): int

Recupere la máscara actual.

setonmodifycallback (llamable $ onModify)

Establezca una función de devolución de llamada que se llama cuando cambia la máscara. Esto puede aprobarse como segundo argumento en el constructor.

GetFlagNames ([int $ Mask, [bool $ asarray = false]])

Dé el nombre (s) para la $mask dada o la máscara actual cuando se omite. Cuando $asArray es true el método devolverá una matriz con los nombres, de lo contrario, se devolverá una cadena separada por comas (predeterminada).

addflag (int $ flag)

Agrega una o múltiples banderas a la máscara actual.

removeflag (int $ flag)

Elimina una o múltiples banderas de la máscara actual.

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

Compruebe si los ind (s) indicadores se establecen en la máscara actual. Por defecto, verificará todos los bits en el indicador dado. Cuando desee hacer coincidir cualquiera de las banderas dadas, establece $checkAll en false .

checkanyflag (int $ máscara): bool

Desde: V1.0.1
Para usted, conveniente, he agregado un alias para checkflag con $checkAll establecido en false .

count (): int

Desde: V1.2.0
Devuelve el número de banderas que se han establecido.

JSonserialize (): Mixto

Desde: V1.2.0
Devuelve un valor que puede ser codificado por JSON_ENCODE () en forma de ["mask" => 7] . No debería tener que llamar a este método directamente, en su lugar, puede pasar el objeto BinaryFlags a JSON_ENCODE que lo convertirá en '{"máscara": 7}'.

Métodos estáticos

Se pueden usar los siguientes métodos estáticos:

getAllflags (): Array

Desde: V1.1.0
Devuelva todas las banderas con sus nombres como una matriz, usando su máscara de bandera como clave. Este método también se puede sobrecargar para devolver los nombres personalizados para los indicadores, que serán utilizados por el método getFlagNames .

getAllflagsmask (): int

Desde: V1.1.0
Devuelve la máscara de todas las banderas juntas

Iteración

Desde: V1.2.0
Puede tratar un objeto BinaryFlags como un iterable, donde cada iteración devolverá el siguiente valor de bit que se ha establecido, incluida su descripción (o el nombre de la constante que representa el valor de bits).

Uso de ejemplo

Debajo de algún ejemplo de código de uso

Crear clases

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

Uso 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

Uso con múltiples banderas

 $ 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

Ejemplo de nombres de la bandera

Por defecto, los nombres de la bandera se basan en los nombres constantes

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

Ejemplo de nombres de bandera personalizados

Si desea nombres de bandera personalizados que no son iguales a los nombres constantes, puede anularlos con 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',
)
*/

Uso de ejemplo con modelos elocuentes

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