For simple objects, it's usually easy to have a "state" attribute that's a string and storeable in a database. For example, imagine a User class. It may be in the states of inactive, unverified, and active. This could be tracked with two boolean values – "active" and "verified" – but it could also use a simple state machine to transition from inactive to unverified to active while storing the current state in that "state" attribute. Very common, right?

However, now imagine a class that has several more boolean attributes and, more importantly, could have lots of combinations of those. For example, a Thing that may be broken, missing, deactivated, outdated, etc. Now, tracking state in a single "state" attribute becomes more difficult. This, I guess, is a Nondeterministic Finite Automaton or State Machine. I don't really want to store states like "inactive_broken" and "active_missing_outdated", etc.

The best I've come up with is to have both the "state" attribute and store some sort of superstate – "available" vs "unavailable", in this case – and each of the booleans. That way I could have a guard-like method when transitioning.

Has anyone else run into this problem and come up with a good solution to tracking states?

• state
• state-machine

Have you considered serializing the "state" to a bit mask and storing it in an integer column in a database? Let's say an entity can be active or inactive, available or unavailable, or working or broken in any combination.

You could store each state as a bit; either on or off. This way a value of 111 would be active, available, and working, while a value of 000 would be inactive, unavailable, and broken.

You could then query for specific combinations using the appropriate bit mask or deserialize the entity to a class with boolean values for each state you are wanting to track. It would also be relatively cheap to add states to an object and would not break already serialized objects.

Same as the answer above but more practical than theory:

• Identify the possible number of Boolean attributes. The state of all these attributes can be represented by 1=true or 0=false

• Take a appropriate sized numeric datatype. unsigned short=16, unsigned int=32, unsigned long=64, if you have an even bigger type take an array of numeric: for instance for 128 attributes take

  unsigned long[] attr= new long[2];  // two long side by side
  

• each bit can be accessed with following code

  bool GetBitAt(long attr, int position){
      return (attr & (1<<(position-1)) >0;
  }
  long SetBitAt(long attr, int position, bool value){
      return attr|=1<<(position-1);
  }
  

• Now have each bit position represent an attribute. E.g: bit 5 means Is Available?

   bool IsAvailable(long attr){
        return GetBitAt(attr, 5);
   }
  

benefits:

• Saves space e.g. 64 attributes will only take 8 bytes.

• Easy saving and reading you simply have to read a short, int or long which is just a simple variable

• Comparing a set of attributes is easy as you will simple compare a short, int or long 's numeric value with the other. e.g. if(Obj.attributes == Obj2.attributes){ }

I think you are describing an example of Orthogonal Regions. From that link, "Orthogonal regions address the frequent problem of a combinatorial increase in the number of states when the behavior of a system is fragmented into independent, concurrently active parts."

One way you might implement this is via object composition. For example, your super object contains several sub-objects. The sub-objects each maintain their associated state independently from one another. The super object's state is the combination of all its sub-object states.

Search for "orthogonal states", "orthogonal regions", or "orthogonal components" for more ideas.