apriltokenizer.h

Go to the documentation of this file.

/* ========================================================================= */
/* ------------------------------------------------------------------------- *//*


 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Please read COPYING and README files in root folder
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
#ifndef __AMODTOKENIZER_INC__
#define __AMODTOKENIZER_INC__
//
//
//
//
/*  INCLUDES    ------------------------------------------------------------ */

#include    <april/april.h>

/*  INCLUDES    ============================================================ */
//
//
//
//
/*  DEFINITIONS    --------------------------------------------------------- */

namespace   april    {

struct
    APRILSHARED_EXPORT
    AaToken     {
    
    enum    Flags   {
        HasSpaces           = 0x0001,
        HasTabs             = 0x0002,
        HasNewLine          = 0x0004,
        HasLineFeed         = HasNewLine,
        HasCR               = 0x0008,
        HasWhites           = HasSpaces | HasTabs | HasNewLine | HasCR,
        
        HasDigits           = 0x0010,
        HasLetters          = 0x0020,
        OnlyHex             = 0x0040,   
        HasComma            = 0x0080,
        HasDot              = 0x0100,
        WasQuoted           = 0x0200,
        
        HasLeadingWhites    = 0x0400,
        HasTrailingWhites   = 0x0800,
        HasMiddleWhites     = 0x1000,
        IsAllWhites         = 0x2000 | HasLeadingWhites | HasMiddleWhites | HasTrailingWhites,
        
        HasLowCodes         = 0x4000,   
        UpperCaseLetters    = 0x8000
    };
    
    void    init            ( void )
    { i_start = -1; i_end = -1; flags = 0; }
    
    bool    isAllWhite      ( void ) const
    { return ( flags & IsAllWhites ) == IsAllWhites; }
    
    bool    leadingWhite    ( void ) const
    { return ( flags & HasLeadingWhites ) == HasLeadingWhites; }
    
    bool    trailingWhite   ( void ) const
    { return ( flags & HasTrailingWhites ) == HasTrailingWhites; }
    
    bool    middleWhite     ( void ) const
    { return ( flags & HasMiddleWhites ) == HasMiddleWhites; }
    
    bool    hasWhiteSpaces  ( void ) const
    { return ( flags & HasWhites ) != 0; }
    
    bool    hasDigits       ( void ) const
    { return ( flags & HasDigits ) != 0; }
    
    bool    hasLetters      ( void ) const
    { return ( flags & HasLetters ) != 0; }
    
    bool    hasComma        ( void ) const
    { return ( flags & HasComma ) != 0; }
    
    bool    hasDot          ( void ) const
    { return ( flags & HasDot ) != 0; }
    
    bool    hasLowCodes     ( void ) const
    { return ( flags & HasLowCodes ) == HasLowCodes; }
    
    bool    hasUpperCaseLetters     ( void ) const
    { return ( flags & UpperCaseLetters ) == UpperCaseLetters; }
    
    bool    hasLowerCaseLetters     ( void ) const
    { return ( ( flags & UpperCaseLetters ) == 0 ) && hasLetters(); }
    
    
    bool    isInteger       ( void ) const
    { 
        return ( isAllWhite() == false ) && 
                ( middleWhite() == false ) && 
                hasDigits() && 
                ( hasLetters() == false ); 
    }
    
    bool    isHexInteger    ( void ) const
    { 
        return ( isAllWhite() == false ) && 
                ( middleWhite() == false ) && 
                ( ( flags & OnlyHex ) == OnlyHex ); 
    }
    
    bool    wasQuoted       ( void ) const
    { return ( flags & WasQuoted ) == WasQuoted; }


    int     i_start;
    
    int     i_end;
    
    int     flags;
    
}; /* struct AaToken */


struct
    APRILSHARED_EXPORT
    AaTkString      {
    
    QString         getToken        ( int i ) const
    { return s_.mid( tk_.at( i ).i_start, tk_.at( i ).i_end - tk_.at( i ).i_start ); }
    
    QString         getToken        ( const AaToken & tk ) const
    { return s_.mid( tk.i_start, tk.i_end - tk.i_start ); }
    

    bool            isString        ( const QString & s_match, int i ) const;
    

    bool            isString        ( int i ) const;
    

    bool            isString        ( const AaToken & tk ) const;
    

    bool            isInteger       ( int i ) const;
    

    bool            isInteger       ( const AaToken & tk ) const;
    

    bool            isHexInteger    ( int i ) const;
    

    bool            isHexInteger    ( const AaToken & tk ) const;
    
    
    
    QString             s_;
    
    QVector<AaToken>    tk_;
    
}; /* struct AaTkString */

/*  DEFINITIONS    ========================================================= */
//
//
//
//
/*  CLASS    --------------------------------------------------------------- */

class
    APRILSHARED_EXPORT
    AprilTokenizer      : public MemTrack       {
    BBM_TRACK( AprilTokenizer );
    
    //
    //
    //
    //
    /*  DEFINITIONS    ----------------------------------------------------- */
    
    /*  DEFINITIONS    ===================================================== */
    //
    //
    //
    //
    /*  DATA    ------------------------------------------------------------ */
    
private:
    
    
    
    /*  DATA    ============================================================ */
    //
    //
    //
    //
    /*  FUNCTIONS    ------------------------------------------------------- */
    
public:
    
    static AaTkString       basicTk         ( const QString & s );
    
    /*  FUNCTIONS    ======================================================= */
    //
    //
    //
    //
    
};  /*  class AprilTokenizer    */

/*  CLASS    =============================================================== */
//
//
//
//

}   //  namespace   april

#endif // __AMODTOKENIZER_INC__
/* ------------------------------------------------------------------------- */
/* ========================================================================= */