Rangement pour vos booléens

Commenter

Contenu du snippet

C'est un type structure qui gère, stocke et facilite l'accès à autant de variable booléenne que vous pourriez avoir besoin. Pour la moment je m'en suis tenu à un accès direct par index, mais dans le futur on pourrait imaginer un accès par clé. Le problème étant que cela aurait pour conséquence d'alourdir la structure.

Source / Exemple : 


/// <summary>
	/// Description résumée de boolz
	/// </summary>
	public struct boolz
	{
		private int[] _tval;
		
		private void AddInt()
		{
			// pas besoin de vérifier que tval est initialisé,
			// puisque nous sommes en présence d'une structure
			int[] temp = new int[this._tval.Length + 1];
			Array.Copy(this._tval,0,temp,0,this._tval.Length);
			temp[this._tval.Length] = 0; // pas nécessaire ... 
			this._tval = temp;
		}

		public boolz(System.Int32 newValue)
		{
			this._tval = new int[1];
			this._tval[0] = newValue;

		}
		public boolz(params bool[] InitialValues)
		{
			int ILen = InitialValues.Length; // valeur utilisée fréquemment
			int TLen = ((ILen - (ILen % 32)) / 32) + 1;
			this._tval = new int[TLen];
			for(int i=0;i<ILen;i++)
				this[i] = InitialValues[i];
		}
		public static implicit operator boolz(System.Int32 NewValue)
		{
			return new boolz(NewValue);
		}
		public static implicit operator boolz(bool[] InitialValues)
		{
			return new boolz(InitialValues);
		}
		public bool this[int position]
		{
			get
			{
				// Si il y a dépassement de capacité
				if(position > (this._tval.Length * 32))
					throw new OverflowException("La position spéficiée excède les possiblités du type actuel.");
				
				// On détermine la position interne sur l'entier
				int tabPosA = position % 32;
				// On détermine la position dans le tableau
				// (De quel entier s'agit-il ?)
				int tabPosB = ((position - tabPosA) / 32) + 1;
				// On fabrique la condition AND appropriée
				int ANDAttr = Convert.ToInt32(Math.Pow(2,tabPosA -1));
				// On vérifie le resultat obtenu et retour.
				if((this._tval[tabPosB-1] & ANDAttr) > 0)
					return true;
				else
					return false;
			}
			set
			{
				// si la position est plus grande que le tableau actuel
				// il faut ajouter autant d'entier que nécessaire
				// pour satisfaire la condition "position".
				if(position > (this._tval.Length * 32))
				{
					int mod = position % 32;
					int len = ((position - mod) / 32) + 1;
					while(this._tval.Length < len)
						AddInt();
				}
				
				// si on arrive ici c'est qu'on a suffisamment d'entier
				// pour réaliser la modification de la valeur
				int tabPosA = position % 32;
				int tabPosB = ((position - tabPosA) / 32) + 1;
				int ANDAttr = Convert.ToInt32(Math.Pow(2,tabPosA -1));
                				
				if(value == true)
				{
					if((this._tval[tabPosB-1] & ANDAttr) == 0)
					{
						this._tval[tabPosB-1] += ANDAttr;
					}
				}
				else
				{
					if((this._tval[tabPosB-1] & ANDAttr) > 0)
					{
						this._tval[tabPosB-1] -= ANDAttr;
					}
				}
			}
		}

	}

Conclusion :


Vous pouvez voir par là, la force des structures pour ce type d'utilisation. Je vous encourage à me faire part de vos impressions.

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (SimonKari)