| /*=========================================================================== |
| FILE: |
| DataParser.h |
| |
| DESCRIPTION: |
| Declaration of sParsedField and cDataParser |
| |
| PUBLIC CLASSES AND METHODS: |
| sParsedField |
| Structure to represent a single parsed field (field ID, offset, |
| size, value, name, etc.) |
| |
| cDataParser |
| Class to parse a buffer into bit/byte specified fields accordinging |
| to a database description, uses cProtocolEntityNav to navigate the DB |
| definition |
| |
| Copyright (c) 2011, Code Aurora Forum. All rights reserved. |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions are met: |
| * Redistributions of source code must retain the above copyright |
| notice, this list of conditions and the following disclaimer. |
| * Redistributions in binary form must reproduce the above copyright |
| notice, this list of conditions and the following disclaimer in the |
| documentation and/or other materials provided with the distribution. |
| * Neither the name of Code Aurora Forum nor |
| the names of its contributors may be used to endorse or promote |
| products derived from this software without specific prior written |
| permission. |
| |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| POSSIBILITY OF SUCH DAMAGE. |
| ===========================================================================*/ |
| |
| //--------------------------------------------------------------------------- |
| // Pragmas |
| //--------------------------------------------------------------------------- |
| #pragma once |
| |
| //--------------------------------------------------------------------------- |
| // Include Files |
| //--------------------------------------------------------------------------- |
| #include "CoreDatabase.h" |
| #include "BitParser.h" |
| #include "ProtocolEntityNav.h" |
| #include "ProtocolBuffer.h" |
| |
| //--------------------------------------------------------------------------- |
| // Definitions |
| //--------------------------------------------------------------------------- |
| class cColorItem; |
| |
| /*=========================================================================*/ |
| // Union uFields |
| // |
| // Union to represent the data of a parsed field |
| /*=========================================================================*/ |
| union uFields |
| { |
| CHAR mS8; |
| UCHAR mU8; |
| SHORT mS16; |
| USHORT mU16; |
| LONG mS32; |
| ULONG mU32; |
| FLOAT mFP32; |
| LONGLONG mS64; |
| ULONGLONG mU64; |
| double mFP64; |
| LPCSTR mpAStr; |
| }; |
| |
| /*=========================================================================*/ |
| // Struct sParsedField |
| // |
| // Structure to represent a parsed field |
| /*=========================================================================*/ |
| struct sParsedField |
| { |
| // Give data parser full access |
| friend class cDataParser; |
| |
| public: |
| // (Inline) Constructor - default |
| sParsedField() |
| : mField(), |
| mOffset( 0 ), |
| mValueString( "" ), |
| mName( "" ), |
| mbValid( false ) |
| { |
| memset( (PVOID)&mValue, 0, sizeof( mValue ) ); |
| }; |
| |
| // Constructor - parameterized |
| sParsedField( |
| const cCoreDatabase & db, |
| const sDB2Field * pField, |
| const std::string & name, |
| cBitParser & bp, |
| bool bGenStrings = true ); |
| |
| // (Inline) Get the raw value string (i.e. unmapped enums) |
| std::string GetRawValueString() const |
| { |
| std::string retStr = ""; |
| std::ostringstream tmp; |
| |
| if (IsValid() == true) |
| { |
| if (mField.mType == eDB2_FIELD_ENUM_UNSIGNED) |
| { |
| if (mField.mbHex == false) |
| { |
| tmp << mValue.mU32; |
| retStr = tmp.str(); |
| } |
| else |
| { |
| tmp << std::ios_base::hex << std::ios_base::uppercase |
| << std::ios_base::showbase << mValue.mU32; |
| retStr = tmp.str(); |
| } |
| } |
| else if (mField.mType == eDB2_FIELD_ENUM_SIGNED) |
| { |
| if (mField.mbHex == false) |
| { |
| tmp << mValue.mS32; |
| retStr = tmp.str(); |
| } |
| else |
| { |
| tmp << std::ios_base::hex << std::ios_base::uppercase |
| << std::ios_base::showbase << mValue.mU32; |
| retStr = tmp.str(); |
| } |
| } |
| else |
| { |
| retStr = mValueString; |
| } |
| } |
| |
| return retStr; |
| }; |
| |
| // (Inline) Get field size in bits |
| ULONG GetSize() const |
| { |
| ULONG sz = 0; |
| if (mField.IsValid() == true) |
| { |
| sz = mField.mSize; |
| } |
| |
| return sz; |
| }; |
| |
| // (Inline) Is this field a string type? |
| bool IsString() const |
| { |
| bool bStr = false; |
| if (IsValid() == false) |
| { |
| return bStr; |
| } |
| |
| if (mField.mType == eDB2_FIELD_STD) |
| { |
| switch ((eDB2StdFieldType)mField.mTypeVal) |
| { |
| case eDB2_FIELD_STDTYPE_STRING_A: |
| case eDB2_FIELD_STDTYPE_STRING_U: |
| case eDB2_FIELD_STDTYPE_STRING_U8: |
| case eDB2_FIELD_STDTYPE_STRING_ANT: |
| case eDB2_FIELD_STDTYPE_STRING_UNT: |
| case eDB2_FIELD_STDTYPE_STRING_U8NT: |
| bStr = true; |
| break; |
| } |
| } |
| |
| return bStr; |
| }; |
| |
| // (Inline) Is this object valid? |
| bool IsValid() const |
| { |
| return mbValid; |
| }; |
| |
| /* Field definition */ |
| sDB2Field mField; |
| |
| /* Bit offset (from start of payload) */ |
| ULONG mOffset; |
| |
| /* Field value */ |
| uFields mValue; |
| |
| /* Field value as a string */ |
| std::string mValueString; |
| |
| /* Partially qualified name of field */ |
| std::string mName; |
| |
| protected: |
| // Parse a string |
| bool ParseString( |
| ULONG numChars, |
| cBitParser & bp ); |
| |
| /* Is this object valid? */ |
| bool mbValid; |
| }; |
| |
| /*=========================================================================*/ |
| // Class cParsedFieldNavigator |
| // |
| // Class to navigate/search parsed fields produced by the above |
| /*=========================================================================*/ |
| class cParsedFieldNavigator |
| { |
| public: |
| // (Inline) Constructor |
| cParsedFieldNavigator( const std::vector <sParsedField> & pf ) |
| : mFields( pf ), |
| mLastIDIndex( ULONG_MAX ) |
| { }; |
| |
| // Get index of the (first) field that matches the field ID, |
| // the search starts from the last success index returned by |
| // a previous call to this method |
| ULONG GetFieldIndex( |
| ULONG fieldID, |
| bool bLoop = false ) const; |
| |
| // (Inline) Get index of the (first) field that matches the |
| // given ID, the search starts from the provided index |
| ULONG GetFieldIndexFrom( |
| ULONG fieldID, |
| ULONG startIndex, |
| bool bLoop = false ) const |
| { |
| mLastIDIndex = startIndex; |
| return GetFieldIndex( fieldID, bLoop ); |
| }; |
| |
| protected: |
| /* The list of parsed fields */ |
| const std::vector <sParsedField> & mFields; |
| |
| /* Index of last field we matched */ |
| mutable ULONG mLastIDIndex; |
| }; |
| |
| /*=========================================================================*/ |
| // Class cDataParser |
| // Class to parse a buffer into bit/byte specified fields |
| /*=========================================================================*/ |
| class cDataParser : public cProtocolEntityNav |
| { |
| public: |
| // Constructor (protocol buffer) |
| cDataParser( |
| const cCoreDatabase & db, |
| const sProtocolBuffer & buffer ); |
| |
| // Constructor (protocol buffer, entity key, and payload) |
| cDataParser( |
| const cCoreDatabase & db, |
| const sProtocolBuffer & buffer, |
| const std::vector <ULONG> & key, |
| const BYTE * pData, |
| ULONG dataLen ); |
| |
| // Destructor |
| virtual ~cDataParser(); |
| |
| // Parse the data to a list of fields/summary text |
| virtual bool Parse( |
| bool bFieldStrings = true, |
| bool bFieldNames = true ); |
| |
| // (Inline) Get the protocol entity name |
| std::string GetEntityName() const |
| { |
| std::string retName = "?"; |
| if (mEntity.mpName != 0 && mEntity.mpName[0] != 0) |
| { |
| retName = mEntity.mpName; |
| } |
| |
| return retName; |
| }; |
| |
| // (Inline) Get the parsed fields |
| typedef std::vector <sParsedField> tParsedFields; |
| const tParsedFields & GetFields() const |
| { |
| return mFields; |
| }; |
| |
| protected: |
| // Working from the back of the current field list find |
| // and return the value for the specified field ID as a |
| // LONGLONG (field type must be able to fit) |
| virtual bool GetLastValue( |
| ULONG fieldID, |
| LONGLONG & val ); |
| |
| // Contiue navigation now that entity has been set? |
| virtual bool ContinueNavigation(); |
| |
| // Process the given field |
| virtual bool ProcessField( |
| const sDB2Field * pField, |
| const std::string & fieldName, |
| LONGLONG arrayIndex = -1 ); |
| |
| // (Inline) Get current working offset |
| virtual ULONG GetOffset() |
| { |
| return mBitsy.GetNumBitsParsed(); |
| }; |
| |
| // (Inline) Set current working offset |
| virtual bool SetOffset( ULONG offset ) |
| { |
| mBitsy.SetOffset( offset ); |
| return true; |
| }; |
| |
| // (Inline) Get current navigation order |
| virtual bool GetLSBMode() |
| { |
| return mBitsy.GetLSBMode(); |
| }; |
| |
| // (Inline) Set current navigation order |
| virtual bool SetLSBMode( bool bLSB ) |
| { |
| // Assume success |
| bool bOK = true; |
| if (bLSB != GetLSBMode()) |
| { |
| if ((GetOffset() % BITS_PER_BYTE) != 0) |
| { |
| // We need to be on a byte boundary |
| bOK = false; |
| } |
| else |
| { |
| mBitsy.SetLSBMode( bLSB ); |
| } |
| } |
| |
| return bOK; |
| }; |
| |
| // Handle special case processing for summary text generation |
| virtual void HandleSpecialCases( |
| std::string & args, |
| std::string & fs ); |
| |
| /* Color item containing the data we are parsing */ |
| sProtocolBuffer mBuffer; |
| |
| /* Entity key */ |
| std::vector <ULONG> mKey; |
| |
| /* The underlying bit parser */ |
| cBitParser mBitsy; |
| |
| /* The list of parsed fields */ |
| tParsedFields mFields; |
| |
| /* Generate field value strings? */ |
| bool mbFieldStrings; |
| |
| /* Did we successfully parse the buffer? */ |
| bool mbParsed; |
| |
| /* Parsed field vector index of last instance of each field (by ID) */ |
| std::map <ULONG, ULONG> mFieldIndices; |
| }; |
| |