Re: finite state machine with enum

i have a byte stream that has to be decoded in a list of simple
containers - basically I do a translation from serial to parallel. The
implementation I'm using now has this form:

public class RawProtocol{

   private long millis=/*some initialization procedure*/;
   public RawProtocol(InputStream inputStream, OutputStream
outputStream){
       this.bq=new LinkedBlockingQueue<Byte>();
       this.is=inputStream;
       this.os=outputStream;
   }

   public RawData getRawData() {
       Byte temp;
       do{
           if((temp=bq.poll())!=null)
           state=state.exec(temp);
           else
               return null;
       }while(state!=Mlsm.START);
       /*...
         return a deserialized packet
        ... */
   }

   enum Mlsm{ //stands for my little state machine

       START {
           public Mlsm exec(byte time){
               pushTime(time); //this byte represents a time and
should be treated in a way
               return TIME_RED;
           }
       },
       TIME_RED {
           public Mlsm exec(byte value){
               pushValue(value); //this is a value and should be
treated in another way
               return VALUE_RED;
           }
       },
       VALUE_RED {
           public Mlsm exec(byte stop){
               switch (stop){
               case stopByte:
                   commit(); //the sequence (time - value) is well
formed and can be saved in a packet
                   return START;
               default: return GARBAGE;
               }
           }
       },
       GARBAGE {
           public Mlsm exec(byte grbg){
               switch (grbg){
               case stopByte: return START;
               default: return this;
               }
           }
       };

       public abstract Mlsm exec(byte b);
   }
}

the machine is activated through getRawData, which makes it perform a
complete cycle to produce a single packet of formatted data

the initial idea to use a state machine implemented as an inner class
was to:
- bring order in the code

- to take advantage of some time-dependent data (millis) managed by the
outer class RawProtocol (most important)