Jump to content
  • Advertisement
Sign in to follow this  
devronious

[.net] Bitwise check - best way?

This topic is 3779 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

I'm looking for the best way to check for a bit within a value. My current operation does the following, but I think it's cumbersome maybe:

//here's the enum with the bitwise values:

    /// <summary>
    /// This enumerates the various data types that can be modified within the buffers of the VertexEngine system.
    /// </summary>
    public enum DataType
    {
        /// <summary>
        /// Indicates None.
        /// </summary>
        None=0,
        /// <summary>
        /// Indicates Vertex data.
        /// </summary>
        Vertex=1,
        /// <summary>
        /// Indicates Index data.
        /// </summary>
        Index = 2,
        /// <summary>
        /// Indicates UV data.
        /// </summary>
        UV = 4
    }

//here's the check I do to see if a member (this.bufferDataChanged) holds one of the enums:

    if ((this.bufferDataChanged & DataType.Vertex) == DataType.Vertex) {do this...}


Thanks for any help, Devin

Share this post


Link to post
Share on other sites
Advertisement
That's pretty much the standard way to check for a bit in a bitfield. If you're looking for that bit and that bit only, then yes, you'll need to be using the == operator. A bitfield is used to indicate a range of options which may exist in any combination. If you only check for one sole condition (a single bit begin set), then you don't want a bitfield, you want a variable holding the enum value.

Share this post


Link to post
Share on other sites
Quote:
If you only check for one sole condition (a single bit begin set), then you don't want a bitfield, you want a variable holding the enum value.


Not sure what you mean, can you explain more please?

Quote:
What's wrong with that? That's the way I do it.


I guess I'm looking for something more C# like :) ya know like:


if (this.bufferDataChanged 'contains' DataType.Vertex) {do this...}



Seems like that would be a pretty common use for us programmers. I guess I thought there was something already there that I was missing. Perhaps not.

Share this post


Link to post
Share on other sites
> Not sure what you mean, can you explain more please?

I assume he means, you don't really need to use bits if only one of the bits can be set a given time, and not multiple bits, so you probably would be better using enumeration or something.

Share this post


Link to post
Share on other sites
Quote:
Original post by KulSeran
you really only need to write
if (this.bufferDataChanged & DataType.Vertex)
the == DataType.Vertex is redundant


Maybe in some other languages, but in C# that statement will return a DataType not a bool, and the compiler will complain.

Share this post


Link to post
Share on other sites
Quote:
Maybe in some other languages, but in C# that statement will return a DataType not a bool, and the compiler will complain.


That's what I thought but wasn't sure. I haven't tried it yet, still just coding, not compiling yet.

Quote:
I assume he means, you don't really need to use bits if only one of the bits can be set a given time, and not multiple bits, so you probably would be better using enumeration or something.


Yea it is a bitwise enumeration:

public enum DataType
{
None=0,
Vertex=1,
Index = 2,
UV = 4,
XYZ = 8,
Norm = 16
}

Setting the values of each enum member to the corresponding bit placement. Then I can mix enum members together as I will. Because I do in fact need to mix two or more enum members together at times.

Share this post


Link to post
Share on other sites
You are only missing one nice feature of .Net, the FlagsAttribute

[Flags]
public enum DataType
{
None=0,
Vertex=1,
Index = 2,
UV = 4,
XYZ = 8,
Norm = 16
}




If you have something like

DataType dt = DataType.Vertex | DataType.Index;

If you are not using the FlagsAttribute, when you check the value while debugging or when you use the ToString you will see the value 3, as expected, but with FlagsAttribute you will see the value "Vertex | Index" while debugging and ToString will return "Vertex, Index" instead of 3, so you don't have to figure out which bits are set while debugging.

Share this post


Link to post
Share on other sites
If you just want to reduce the amount of typing you do, you can use != 0 rather than == DataType.Vertex. Or for the evil operator overloading crowd:

class Contains {
Contains(DataType d) { v = d; }
DataType v;
public static bool operator &(Contains c, DataType d) {
return (c.v & d) != 0;
}
public static explicit operator Contains(DataType d) {
return new Contains(d);
}
}

if ((Contains)this.bufferDataChanged & DataType.Vertex) {do this...}

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

Participate in the game development conversation and more when you create an account on GameDev.net!

Sign me up!