begin process at 2012 05 27 16:54:56
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths & Algorithmes

 > BITWISE HANDLER : GESTION DES BITS POUR GÉRER LES DROITS

BITWISE HANDLER : GESTION DES BITS POUR GÉRER LES DROITS


 Information sur la source

Note :
10 / 10 - par 2 personnes
10,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Maths & Algorithmes Classé sous :BITWISE, OPERATEURS BITS, BYTE Niveau :Débutant Date de création :22/12/2008 Date de mise à jour :23/12/2008 10:45:04 Vu / téléchargé :2 876 / 113

Auteur : aKheNathOn

Ecrire un message privé
Site perso
Commentaire sur cette source (5)
Ajouter un commentaire et/ou une note

 Description

Après la lecture de la source intéressante de malalam : http://www.phpcs.com/codes/SQUELETTE-GESTION-DROIT S_48756.aspx

J'ai voulu expérimenter également la possibilité de gérer les bits.

Le contexte est le même : j'ai une classe qui peut avoir plusieurs variables avec deux états (on/off) avec le besoin de vérifier que les états se croisent.

Un utilisateur qui aurait un ensemble de droits serait le parfait exemple.

Deux choses sont traités dans ma proposition - la première étant la gestion des bits, la seconde étant le moyen d'encapsuler les propriétés (puis de les exploiter).

Regardez le code pour plus de détails.

Source

  • <?php
  • /**
  • * Classe de gestion des bits
  • */
  • abstract class byte {
  • private $value;
  • private $const;
  • public function __construct($value = 0) {
  • $this->value = $value;
  • }
  • public function set($flag, $value) {
  • if ($value) {
  • // SET BIT 1
  • $this->value = $this->value | $flag;
  • } else {
  • // SET BIT 0
  • $this->value = $this->value & ~$flag;
  • }
  • }
  • public function get($flag) {
  • return (($this->value & $flag) == $flag);
  • }
  • public function get_enum() {
  • if (!$this->const) {
  • $reflect = new ReflectionClass(get_class($this));
  • $this->const = $reflect->getConstants();
  • }
  • return $this->const;
  • }
  • public function __get($key) {
  • $c = $this->get_enum();
  • if (isset($c[$key])) {
  • return $this->get($c[$key]);
  • } else throw new Exception('Definition not found');
  • }
  • public function __set($key, $value) {
  • if (!is_bool($value)) throw new Exception('Boolean value expected !');
  • $c = $this->get_enum();
  • if (isset($c[$key])) {
  • return $this->set($c[$key], $value);
  • } else throw new Exception('Definition not found for '.$key);
  • }
  • public function __call($func, $args) {
  • $action = substr($func, 0, 3);
  • $key = strtolower(substr($func, 3));
  • $c = $this->get_enum();
  • if ($action == 'can') {
  • if (isset($c[$key])) {
  • return $this->get($c[$key]);
  • } else throw new Exception('Definition not found for '.$key);
  • } else if($action == 'set') {
  • if (isset($c[$key])) {
  • if (isset($args[0])) {
  • if (is_bool($args[0])) {
  • return $this->set($c[$key], $args[0]);
  • } else {
  • throw new Exception('Boolean value expected !');
  • }
  • } else {
  • return $this->set($c[$key], true);
  • }
  • } else throw new Exception('Definition not found for '.$key);
  • } else throw new Exception('Undefined function '.$func);
  • }
  • }
  • /**
  • * Un exemple de classe
  • */
  • class userRights extends byte {
  • const read = 1; // 001
  • const write = 2; // 010
  • const delete = 4; // 100
  • const admin = 7; // 111
  • }
  • /**
  • * Instanciation avec valeurs par défaul
  • */
  • $foo = new userRights(
  • userRights::read |
  • userRights::write |
  • userRights::delete
  • );
  • // MANIPULATION
  • $foo->write = false;
  • $foo->setRead(false);
  • $foo->setRead();
  • // AFFICHAGE
  • echo 'Read : '.$foo->read.'<hr />';
  • echo 'Write : '.$foo->write.'<hr />';
  • echo 'Delete : '.$foo->canDelete();
  • ?>
<?php

	/**
	 * Classe de gestion des bits
	 */	 	
	abstract class byte {
		private $value;
		private $const;
		public function __construct($value = 0) {
			$this->value = $value;
		}
		public function set($flag, $value) {
			if ($value) {
				// SET BIT 1
				$this->value = $this->value | $flag;
			} else {
				// SET BIT 0
				$this->value = $this->value & ~$flag;
			}
		}
		public function get($flag) {
			return (($this->value & $flag) == $flag);
		}
		public function get_enum() {
			if (!$this->const) {
			    $reflect = new ReflectionClass(get_class($this));
		    	$this->const = $reflect->getConstants();
			}
		    return $this->const;
		}
		public function __get($key) {
			$c = $this->get_enum();
			if (isset($c[$key])) {
				return $this->get($c[$key]);
			} else throw new Exception('Definition not found');
		}
		public function __set($key, $value) {
			if (!is_bool($value)) throw new Exception('Boolean value expected !');
			$c = $this->get_enum();
			if (isset($c[$key])) {
				return $this->set($c[$key], $value);
			} else throw new Exception('Definition not found for '.$key);
		}
		public function __call($func, $args) {
			$action = substr($func, 0, 3);
			$key = strtolower(substr($func, 3));
			$c = $this->get_enum();
			if ($action == 'can') {
				if (isset($c[$key])) {
					return $this->get($c[$key]);
				} else throw new Exception('Definition not found for '.$key);				
			} else if($action == 'set') {
				if (isset($c[$key])) {
					if (isset($args[0])) {
						if (is_bool($args[0])) {
							return $this->set($c[$key], $args[0]);
						} else {
							throw new Exception('Boolean value expected !');
						}
					} else {
						return $this->set($c[$key], true);
					}
				} else throw new Exception('Definition not found for '.$key);								
			} else throw new Exception('Undefined function '.$func);
		}
	}

	/**
	 * Un exemple de classe
	 */	 	
	class userRights extends byte {
		const read		= 1; // 001
		const write		= 2; // 010
		const delete		= 4; // 100
		const admin		= 7; // 111
	}

	/**
	 * Instanciation avec valeurs par défaul
	 */	 	
	$foo = new userRights(
		userRights::read |
		userRights::write | 
		userRights::delete
	);
	
	// MANIPULATION
	$foo->write = false;
	$foo->setRead(false);
	$foo->setRead();
	
	// AFFICHAGE
	echo 'Read : '.$foo->read.'<hr />';
	echo 'Write : '.$foo->write.'<hr />';
	echo 'Delete : '.$foo->canDelete();
?>

 Conclusion

Le premier avantage à utiliser cette méthode d'encapsultation est que vous définissez les constantes (pas de collision de noms possible) et vous exploitez directement les bits à travers des fonctions encapsulées.

Donc source utilisable par tout le monde :)

Regardez le fichier example.php pour voir comment c'est simple d'utilisation.

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Historique

23 décembre 2008 10:45:04 :
Modif des codes de l'hexa vers le binaire (malalam)

 Sources du même auteur

CLASSE WIKILOC
Source avec Zip OBSERVER PATTERN ORIENTÉ DÉVELOPPEMENT ÉVÉNEMENTIEL DÉCLARAT...
Source avec Zip SERVICE DESIGN PATTERN / CHARGEMENT DYNAMIQUE DE SERVICES D'...
Source avec Zip Source avec une capture WHOIS DOMAIN CLASS : LOOKUP & AVAIBILITY
Source avec Zip Source avec une capture XML MAPPING TO CLASS OBJECTS / CHARGEMENT / PARSING / MODIFI...

 Sources de la même categorie

EXEMPLE D'APPLICATION DE L'ALGORITHME DE DIJKSTRA EN PHP par philtr8
CLEF POUR EAN 13 ET 14 par RaftY
FONCTION DE CALCUL DU NOMBRE DE DUEL UNIQUE POUR UN NOMBRE N... par mtrix000
Source avec Zip Source avec une capture TRIANGLE DE PASCAL ET SON ÉQUATION par vendeeHdLR89
Source avec Zip CONVERTISSEUR LAMBERT2 ÉTENDU EN COORDONNÉE GÉOGRAPHIQUE (LO... par varfendell

 Sources en rapport avec celle ci

Source avec Zip CONVERSION DES UNITÉS INFORMATIQUE (O, KIO, MIO, GIO, TIO...... par genetApt151

Commentaires et avis

Commentaire de malalam le 22/12/2008 19:27:39 administrateur CS

Hello Akhe,

je fais vite...j'ai pas trop le temps: c'est très intéressant, j'ai pas décortiqué du tout, j'ai parcouru, mais d'emblée un truc me gène quand même : 0x100, c'est pas une notation binaire, c'est de l'hexa. Du coup, gare aux surprises!
0x100 << 2 n'est pas égal à 16, mais à 1024.
Car (int)0x100 === 256
(FF + 1, quoi)

Commentaire de malalam le 22/12/2008 19:30:43 administrateur CS

Après, ça change (à priori) rien au fonctionnement hein...PHP va les gérer comme des entiers dans les deux cas.
C'était juste pour préciser à ceux qui lisent ce code.

Commentaire de spipod le 23/12/2008 10:10:22 10/10

Niveau débutant ??? je ne pense pas ;)

Pour la petite erreur, cela ne change rien, les positions binaires active ne sont pas les mêmes, mais s'il faut gérer plus de droit, je ne conseille pas cette notation.

Définir ses constantes, c'est une bonne idée ! et je trouve cela très exploitable.

Commentaire de aKheNathOn le 23/12/2008 10:51:41

Lut, merci pour la précision - je viens de convertir ça en decimales correspondant aux valeurs des bits. Dommage qu'il n'y ait pas de syntaxe pour écrire directement une valeur binaire.

Je viens de rajouter un zip avec un fichier example.php - je t'assure spipod c'est du niveau débutant en terme d'exploitation - aussi simple qu'un hello world.

Ptite astuce qui fait l'un des intérêts d'utiliser du binaire : vous pouvez définir dans un même fichier des droits genre, lecture, ecriture, suppression ...etc... et des niveaux genre annonyme, admin, visiteur ...etc...

Exemple illustré avec 'admin' dans example.php :

- read   : 001
- write  : 010
- delete : 100

- admin  : 111 (all)
- guest  : 001 (only read)
- editor : 011 (read + write)

Bonne prog et merci malalam pour la correction

Commentaire de exar le 11/02/2009 18:46:47 10/10

Hello !
Sincèrement, j'ai lu plusieurs de tes sources, c'est super instructif !  Excellent travail !
Bonne continuation !

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

longueur d'une chaine, en byte... [ par pysco68 ] bonjour les gens!!bon je me bats avec une petite fonction qui me génère un fichier  CSV (valeurs séparées par virgule...) jusque là tout va bien le to


Nos sponsors


Sondage...

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir



 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,546 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales