EnumStates class | C# Online Compiler

EnumStates class by prime31

using System;


public class Program
{
	public enum States
	{
		None = 0,
		Idle = 1 << 0,
		Walk = 1 << 1,
		Jump = 1 << 2
	}
	
	
	static EnumState<States> _states = new EnumState<States>();
	
	
	public static void Main()
	{
		log( _states );
		
		_states.set( States.Idle );
		log( _states );
		log( "is Idle: {0}", _states.isSet( States.Idle ) );
		log( "isOnly Idle: {0}", _states.isOnly( States.Idle ) );
		
		_states.set( States.Jump );
		log( _states );
		log( "is Idle: {0}", _states.isSet( States.Idle ) );
		
		_states.add( States.Idle );
		log( _states );
		log( "is Idle: {0}", _states.isSet( States.Idle ) );
		log( "isOnly Idle: {0}", _states.isOnly( States.Idle ) );
		
		
		log( "" );
		
		
		var flag = 0;
		log( "is 1 set: {0}", Flags.isUnshiftedFlagSet( flag, 1 ) );
		Flags.setFlag( ref flag, 1 );
		log( Flags.binaryStringRepresentation( flag ) );
		log( "is 1 set: {0}", Flags.isUnshiftedFlagSet( flag, 1 ) );

		Flags.setFlag( ref flag, 2 );
		Flags.setFlag( ref flag, 3 );
		log( Flags.binaryStringRepresentation( flag ) );
		log( "is 2 set: {0}", Flags.isUnshiftedFlagSet( flag, 2 ) );		
		
		
		Flags.invertFlags( ref flag );
		log( Flags.binaryStringRepresentation( flag ) );
		log( "is 2 set: {0}", Flags.isUnshiftedFlagSet( flag, 2 ) );
	}
	
	
	public static void log( object obj, params object[] stuff )
	{
		Console.WriteLine( obj.ToString(), stuff );
	}
}





	/// <summary>
	/// utility class to assist with dealing with bitmasks. All methods except isFlagSet expect the flag parameter to be a non-shifted flag.
	/// This lets you use plain old ints (0, 1, 2, 3, etc) to set/unset your flags.
	/// </summary>
	public static class Flags
	{
		/// <summary>
		/// checks to see if the bit flag is set in the int. This check expects flag to be shifted already!
		/// </summary>
		/// <returns><c>true</c>, if flag set was ised, <c>false</c> otherwise.</returns>
		/// <param name="self">Self.</param>
		/// <param name="flag">Flag.</param>
		public static bool isFlagSet( this int self, int flag )
		{
			return ( self & flag ) != 0;
		}


		/// <summary>
		/// checks to see if the bit flag is set in the int
		/// </summary>
		/// <returns><c>true</c>, if flag set was ised, <c>false</c> otherwise.</returns>
		/// <param name="self">Self.</param>
		/// <param name="flag">Flag.</param>
		public static bool isUnshiftedFlagSet( this int self, int flag )
		{
			flag = 1 << flag;
			return ( self & flag ) != 0;
		}


		/// <summary>
		/// sets the flag bit of the int removing any already set flags
		/// </summary>
		/// <param name="self">Self.</param>
		/// <param name="flag">Flag.</param>
		public static void setFlagExclusive( ref int self, int flag )
		{
			self = 1 << flag;
		}


		/// <summary>
		/// sets the flag bit of the int
		/// </summary>
		/// <param name="self">Self.</param>
		/// <param name="flag">Flag.</param>
		public static void setFlag( ref int self, int flag )
		{
			self = ( self | 1 << flag );
		}


		/// <summary>
		/// unsets the flag bit of the int
		/// </summary>
		/// <param name="self">Self.</param>
		/// <param name="flag">Flag.</param>
		public static void unsetFlag( ref int self, int flag )
		{
			flag = 1 << flag;
			self = ( self & ( ~flag ) );
		}



		/// <summary>
		/// inverts the set bits of the int
		/// </summary>
		/// <param name="self">Self.</param>
		public static void invertFlags( ref int self )
		{
			self = ~self;
		}


		/// <summary>
		/// prints the binary representation of the int. Handy for debugging int flag overlaps visually.
		/// </summary>
		/// <returns>The string representation.</returns>
		/// <param name="self">Self.</param>
		/// <param name="leftPadWidth">Left pad width.</param>
		public static string binaryStringRepresentation( this int self, int leftPadWidth = 32 )
		{
			return Convert.ToString( self, 2 ).PadLeft( leftPadWidth, '0' );
		}

	}




 

public class EnumState<T> where T : struct, IComparable, IConvertible, IFormattable
{
	public int state = 0;
	public int previousstate = 0;


	public EnumState()
	{}
		
 
	public EnumState( T state )
	{
		set( state );
	}
	
 
	public void clear()
	{
		previousstate = state;
		this.state = 0;
	}
 
 
	public void set( T state )
	{
		previousstate = this.state;
		this.state = Convert.ToInt32( state );
	}
 
 
	public void add( T state )
	{
		previousstate = this.state;
		this.state |= Convert.ToInt32( state );
	}
	
 
	public void remove( T state )
	{
		previousstate = this.state;
		this.state &= ~Convert.ToInt32( state );
	}
	
 
	public void toggle( T state )
	{
		previousstate = this.state;
		this.state ^= Convert.ToInt32( state );
	}
 
 
	public bool isSet( T state )
	{
		return ( this.state & Convert.ToInt32( state ) ) != 0 ? true : false;
	}
	
 
	public bool isOnly( T state )
	{
		return this.state == Convert.ToInt32( state ) ? true : false;
	}
	
 
	public bool isNone()
	{
		return state == 0 ? true : false;
	}
 
 
	public bool wasSet( T state )
	{
		return ( previousstate & Convert.ToInt32( state )) != 0 ? true : false;
	}
 
 
	public bool wasOnly( T state )
	{
		return previousstate == Convert.ToInt32( state ) ? true : false;
	}
 
 
	public bool any()
	{
		return state != 0 ? true : false;
	}
 
 
	public bool wasAny()
	{
		return previousstate != 0 ? true : false;
	}
 
 
	public override string ToString()
	{
		var b = new char[32];
		var pos = 31;
		var i = 0;
 
		while( i < 32 )
		{
			b[pos] = ( state & ( 1 << i ) ) != 0 ? '1' : '0';
			pos--;
			i++;
		}
		
		return new string( b );
	}
	
}

​x
 
using System;
​
​
public class Program
{
    public enum States
    {
        None = 0,
        Idle = 1 << 0,
        Walk = 1 << 1,
        Jump = 1 << 2
    }
    
    
    static EnumState<States> _states = new EnumState<States>();
    
    
    public static void Main()
    {
        log( _states );
        
        _states.set( States.Idle );
        log( _states );
        log( "is Idle: {0}", _states.isSet( States.Idle ) );
        log( "isOnly Idle: {0}", _states.isOnly( States.Idle ) );
        
        _states.set( States.Jump );
        log( _states );
        log( "is Idle: {0}", _states.isSet( States.Idle ) );
        
        _states.add( States.Idle );
        log( _states );
        log( "is Idle: {0}", _states.isSet( States.Idle ) );
        log( "isOnly Idle: {0}", _states.isOnly( States.Idle ) );
        
        
        log( "" );
        
        
        var flag = 0;
        log( "is 1 set: {0}", Flags.isUnshiftedFlagSet( flag, 1 ) );
        Flags.setFlag( ref flag, 1 );
        log( Flags.binaryStringRepresentation( flag ) );
        log( "is 1 set: {0}", Flags.isUnshiftedFlagSet( flag, 1 ) );
​
        Flags.setFlag( ref flag, 2 );
        Flags.setFlag( ref flag, 3 );
        log( Flags.binaryStringRepresentation( flag ) );
        log( "is 2 set: {0}", Flags.isUnshiftedFlagSet( flag, 2 ) );        
        
        
        Flags.invertFlags( ref flag );
        log( Flags.binaryStringRepresentation( flag ) );
        log( "is 2 set: {0}", Flags.isUnshiftedFlagSet( flag, 2 ) );
    }
    
    
    public static void log( object obj, params object[] stuff )
    {
        Console.WriteLine( obj.ToString(), stuff );
    }
}
​
​
​
​
​
    /// <summary>
    /// utility class to assist with dealing with bitmasks. All methods except isFlagSet expect the flag parameter to be a non-shifted flag.
    /// This lets you use plain old ints (0, 1, 2, 3, etc) to set/unset your flags.
    /// </summary>
    public static class Flags
    {
        /// <summary>
        /// checks to see if the bit flag is set in the int. This check expects flag to be shifted already!
        /// </summary>
        /// <returns><c>true</c>, if flag set was ised, <c>false</c> otherwise.</returns>
        /// <param name="self">Self.</param>
        /// <param name="flag">Flag.</param>
        public static bool isFlagSet( this int self, int flag )
        {
            return ( self & flag ) != 0;
        }
​
​
        /// <summary>
        /// checks to see if the bit flag is set in the int
        /// </summary>
        /// <returns><c>true</c>, if flag set was ised, <c>false</c> otherwise.</returns>
        /// <param name="self">Self.</param>
        /// <param name="flag">Flag.</param>
        public static bool isUnshiftedFlagSet( this int self, int flag )
        {
            flag = 1 << flag;
            return ( self & flag ) != 0;
        }
​
​
        /// <summary>
        /// sets the flag bit of the int removing any already set flags
        /// </summary>
        /// <param name="self">Self.</param>
        /// <param name="flag">Flag.</param>
        public static void setFlagExclusive( ref int self, int flag )
        {
            self = 1 << flag;
        }
​
​
        /// <summary>
        /// sets the flag bit of the int
        /// </summary>
        /// <param name="self">Self.</param>
        /// <param name="flag">Flag.</param>
        public static void setFlag( ref int self, int flag )
        {
            self = ( self | 1 << flag );
        }
​
​
        /// <summary>
        /// unsets the flag bit of the int
        /// </summary>
        /// <param name="self">Self.</param>
        /// <param name="flag">Flag.</param>
        public static void unsetFlag( ref int self, int flag )
        {
            flag = 1 << flag;
            self = ( self & ( ~flag ) );
        }
​
​
​
        /// <summary>
        /// inverts the set bits of the int
        /// </summary>
        /// <param name="self">Self.</param>
        public static void invertFlags( ref int self )
        {
            self = ~self;
        }
​
​
        /// <summary>
        /// prints the binary representation of the int. Handy for debugging int flag overlaps visually.
        /// </summary>
        /// <returns>The string representation.</returns>
        /// <param name="self">Self.</param>
        /// <param name="leftPadWidth">Left pad width.</param>
        public static string binaryStringRepresentation( this int self, int leftPadWidth = 32 )
        {
            return Convert.ToString( self, 2 ).PadLeft( leftPadWidth, '0' );
        }
​
    }
​
​
​
​
 
​
public class EnumState<T> where T : struct, IComparable, IConvertible, IFormattable
{
    public int state = 0;
    public int previousstate = 0;
​
​
    public EnumState()
    {}
        
 
    public EnumState( T state )
    {
        set( state );
    }
    
 
    public void clear()
    {
        previousstate = state;
        this.state = 0;
    }
 
 
    public void set( T state )
    {
        previousstate = this.state;
        this.state = Convert.ToInt32( state );
    }
 
 
    public void add( T state )
    {
        previousstate = this.state;
        this.state |= Convert.ToInt32( state );
    }
    
 
    public void remove( T state )
    {
        previousstate = this.state;
        this.state &= ~Convert.ToInt32( state );
    }
    
 
    public void toggle( T state )
    {
        previousstate = this.state;
        this.state ^= Convert.ToInt32( state );
    }
 
 
    public bool isSet( T state )
    {
        return ( this.state & Convert.ToInt32( state ) ) != 0 ? true : false;
    }
    
 
    public bool isOnly( T state )
    {
        return this.state == Convert.ToInt32( state ) ? true : false;
    }
    
 
    public bool isNone()
    {
        return state == 0 ? true : false;
    }
 
 
    public bool wasSet( T state )
    {
        return ( previousstate & Convert.ToInt32( state )) != 0 ? true : false;
    }
 
 
    public bool wasOnly( T state )
    {
        return previousstate == Convert.ToInt32( state ) ? true : false;
    }
 
 
    public bool any()
    {
        return state != 0 ? true : false;
    }
 
 
    public bool wasAny()
    {
        return previousstate != 0 ? true : false;
    }
 
 
    public override string ToString()
    {
        var b = new char[32];
        var pos = 31;
        var i = 0;
 
        while( i < 32 )
        {
            b[pos] = ( state & ( 1 << i ) ) != 0 ? '1' : '0';
            pos--;
            i++;
        }
        
        return new string( b );
    }
    
}
​
​
​

Compilation error (line 2, col 7): The type or namespace name 'Xamarin' could not be found (are you missing a using directive or an assembly reference?)

Last Run:	6:27:56 pm
Compile:	0s
Execute:	0.156s
Memory:	0b
CPU:	0s

View IL Code