finite state machine with enum

Discussion in 'Java' started by andijcr, Feb 10, 2010.

  1. andijcr

    andijcr Guest

    hi all
    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)

    However enum is defined as static, and this disables access to the
    fields of rawprotocol.
    The main issue then is: how can I make a private field (not static) of
    RawProtocol accessible (read at least) to Mlsm, in an elegant way and
    java-esque way?

    The main issue then is: how can I make a field private (not static)
    RawProtocol accessible (for reading at least) to Mlsm, in an elegant
    way and to objects?

    The first ideas I had (but I would like to avoid) were to delegate to
    the state machine only the definition of the sequence of operations,
    implementing the same operations as methods of an instance of
    RawProtocol;
    Or convert `enum Mlsm` in an inner `class Mlsm` that acts as enum
    (rewriting all the methods that would otherwise be handled
    automatically by the compiler) except for the fact to be not static.

    Or convert enum Mlsm in an inner class that acts as Mlsm enum (then
    writing all the methods that would otherwise be handled automatically
    by the compiler) except that it is not static.

    other ideas - standard methodologies to resolve the issue?
    andijcr, Feb 10, 2010
    #1
    1. Advertising

  2. andijcr

    Lew Guest

    andijcr wrote:
    > The main issue then is: how can I make a field private (not static)
    > RawProtocol accessible (for reading at least) to Mlsm, in an elegant
    > way and to objects?


    Pass it as an argument to the enum 'exec' method.

    --
    Lew
    Lew, Feb 10, 2010
    #2
    1. Advertising

  3. andijcr

    Tom Anderson Guest

    On Wed, 10 Feb 2010, andijcr wrote:

    > 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


    Seriously? You think that's more ordered than:

    DataInputStream in;
    while (true) {
    pushTime(in.readByte());
    pushValue(in.readByte());
    byte stop = in.readByte();
    if (stop == stopByte) {
    commit();
    }
    else {
    while ((stop = in.readByte()) != stopByte);
    }
    }

    ?

    If what you've posted is really what you're doing, and not a huge
    simplification of what you're actually doing, then you've massively
    overcomplicated this.

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


    I don't see why you couldn't do that with the above loop.

    tom

    --
    It's rare that you're simply presented with a knob whose only two
    positions are "Make History" and "Flee Your Glorious Destiny." --
    Tycho Brahae
    Tom Anderson, Feb 10, 2010
    #3
  4. andijcr

    andijcr Guest

    On 10 Feb, 20:02, Tom Anderson <> wrote:
    > On Wed, 10 Feb 2010, andijcr wrote:
    > > 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

    >
    > Seriously? You think that's more ordered than:
    >
    > DataInputStream in;
    > while (true) {
    >         pushTime(in.readByte());
    >         pushValue(in.readByte());
    >         byte stop = in.readByte();
    >         if (stop == stopByte) {
    >                 commit();
    >         }
    >         else {
    >                 while ((stop = in.readByte()) != stopByte);
    >         }
    >
    > }
    >
    > ?
    >
    > If what you've posted is really what you're doing, and not a huge
    > simplification of what you're actually doing, then you've massively
    > overcomplicated this.
    >
    > > - to take advantage of some time-dependent data (millis) managed by the
    > > outer class RawProtocol (most important)

    >
    > I don't see why you couldn't do that with the above loop.
    >
    > tom
    >
    > --
    > It's rare that you're simply presented with a knob whose only two
    > positions are "Make History" and "Flee Your Glorious Destiny." --
    > Tycho Brahae


    the snippet is a simplification of the real code, tough it is not so
    much more complicated. Here i made the decision to use a simple
    implementation of a state machine, instead of a sequence of methods,
    for the elasticity i can obtain in the interpretation of the not-so-
    stable underlying protocol.
    andijcr, Feb 10, 2010
    #4
  5. andijcr

    Tom Anderson Guest

    On Wed, 10 Feb 2010, andijcr wrote:

    > On 10 Feb, 20:02, Tom Anderson <> wrote:
    >> On Wed, 10 Feb 2010, andijcr wrote:
    >>
    >>> 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

    >>
    >> Seriously? You think that's more ordered than:
    >>
    >> DataInputStream in;
    >> while (true) {
    >>         pushTime(in.readByte());
    >>         pushValue(in.readByte());
    >>         byte stop = in.readByte();
    >>         if (stop == stopByte) {
    >>                 commit();
    >>         }
    >>         else {
    >>                 while ((stop = in.readByte()) != stopByte);
    >>         }
    >>
    >> }
    >>
    >> ?
    >>
    >> If what you've posted is really what you're doing, and not a huge
    >> simplification of what you're actually doing, then you've massively
    >> overcomplicated this.
    >>
    >>> - to take advantage of some time-dependent data (millis) managed by the
    >>> outer class RawProtocol (most important)

    >>
    >> I don't see why you couldn't do that with the above loop.

    >
    > the snippet is a simplification of the real code, tough it is not so
    > much more complicated. Here i made the decision to use a simple
    > implementation of a state machine, instead of a sequence of methods, for
    > the elasticity i can obtain in the interpretation of the not-so- stable
    > underlying protocol.


    Do you configure the state machine from a file or similar? If not, it's no
    more plastic than code.

    People have this idea that once code is written, it's hard to change. This
    is wrong.

    tom

    --
    Big Bang. No god. Fadeout. End. -- Stephen Baxter
    Tom Anderson, Feb 10, 2010
    #5
  6. andijcr

    andijcr Guest

    On 10 Feb, 19:15, Lew <> wrote:
    > andijcr wrote:
    > > The main issue then is: how can I make a field private (not static)
    > > RawProtocol accessible (for reading at least) to Mlsm, in an elegant
    > > way and to objects?

    >
    > Pass it as an argument to the enum 'exec' method.
    >
    > --
    > Lew


    I don't really like this solution - the field in the real code is
    needed only in one of the eight states (while other states could in
    the future require access to other fields).
    My point here was to find if an elegant implementation is possible -
    which seems impossible in the way i imagined.
    Eventually my current solution works and is object-oriented. thanks
    for your interest anyway.
    andijcr, Feb 10, 2010
    #6
  7. andijcr

    Roedy Green Guest

    On Wed, 10 Feb 2010 09:53:28 -0800 (PST), andijcr <>
    wrote, quoted or indirectly quoted someone who said :

    > 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;


    I have written quite a few of theses things for JDisplay to colourise
    various sorts of text, e.g. Java, HTML, manifests, bat files.

    See
    https://wush.net/websvn/mindprod/listing.php?repname=mindprod&path=/com/mindprod/jprep/
    --
    Roedy Green Canadian Mind Products
    http://mindprod.com

    Every compilable program in a sense works. The problem is with your unrealistic expections on what it will do.
    Roedy Green, Feb 12, 2010
    #7
  8. andijcr

    Daniel Pitts Guest

    On 2/10/2010 3:12 PM, andijcr wrote:
    > On 10 Feb, 19:15, Lew<> wrote:
    >> andijcr wrote:
    >>> The main issue then is: how can I make a field private (not static)
    >>> RawProtocol accessible (for reading at least) to Mlsm, in an elegant
    >>> way and to objects?

    >>
    >> Pass it as an argument to the enum 'exec' method.
    >>
    >> --
    >> Lew

    >
    > I don't really like this solution - the field in the real code is
    > needed only in one of the eight states (while other states could in
    > the future require access to other fields).
    > My point here was to find if an elegant implementation is possible -
    > which seems impossible in the way i imagined.
    > Eventually my current solution works and is object-oriented. thanks
    > for your interest anyway.


    Using similar to the flyweight pattern. I often have the following design:

    public class State {
    private int someStateField;
    private String someOtherStateField;
    StateNode node = StateNode.A;

    public void transition(Object input) {
    node.transition(this, input);
    }

    private enum StateNode {
    A { public void transition(State state, Object input) { ... }},
    B { public void transition(State state, Object input) { ... }},
    C { public void transition(State state, Object input) { ... }};
    public abstract void transition(State state, Object input);
    }
    }






    --
    Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>
    Daniel Pitts, Feb 12, 2010
    #8
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. deejayfred
    Replies:
    0
    Views:
    526
    deejayfred
    Oct 2, 2003
  2. SomeDude
    Replies:
    3
    Views:
    3,125
    arant
    Aug 14, 2006
  3. Inderkal
    Replies:
    8
    Views:
    1,218
    rickman
    Dec 9, 2004
  4. Roberto Nunnari
    Replies:
    2
    Views:
    8,504
    Thomas Weidenfeller
    Feb 4, 2004
  5. Davide T

    "Tag" Finite State Machine

    Davide T, Dec 10, 2003, in forum: HTML
    Replies:
    5
    Views:
    406
    Eric Bohlman
    Dec 10, 2003
Loading...

Share This Page