pqdinfo.cpp

PQDIF软件包(SDK,Software Development Kit),它能转换、生成并且显示PQDIF文件.对于开发电力系统的数据输出非常有用。

/*
**  CPQDIF_Info class. Implements informational member functions so that
**  certain types of information can be encapsulated here. This allows us
**  to concentrate knowledge at one point so it can be more easily managed.
**  --------------------------------------------------------------------------
**  This class is a Singleton class; this means that only one instance of it
**  should ever be created. This instance is made global, and is one of the
**  only global objects in the entire system.
**  --------------------------------------------------------------------------
**
**  File name:          $Workfile: pqdinfo.cpp $
**  Last modified:      $Modtime: 11/10/98 4:58p $
**  Last modified by:   $Author: Bill $
**
**  VCS archive path:   $Archive: /Hank/DMM/FirmWare/Level3/ObDatMgr/pqdinfo.cpp $
**  VCS revision:       $Revision: 8 $ 
*/
#include "PQDIF_classes.h"


//  The one and only information object (Singleton)
//  ===================================
CPQDIF_Info  theInfo;


//  Local macros for adding entries
//  -------------------------------
#define ADD_TAG_ENTRY( tagTHING )\
    nameTag.m_tag = tagTHING; \
    nameTag.m_name = #tagTHING; \
    m_listTags.push_back( nameTag );

#define ADD_ID_GUID_ENTRY( valueID, tagID )\
    nameGuid.m_id = valueID; \
    nameGuid.m_tag = tagID; \
    nameGuid.m_name = #valueID; \
    m_listGUIDs.push_back( nameGuid );

#define ADD_ID_UINT4_ENTRY( valueID, tagID )\
    nameInt.m_id = valueID; \
    nameInt.m_tag = tagID; \
    nameInt.m_name = #valueID; \
    m_listInts.push_back( nameInt );

#define ADD_TYPE_ENTRY( typeTHING )\
    nameType.m_type = typeTHING; \
    nameType.m_name = #typeTHING; \
    m_listTypes.push_back( nameType );



//  Construction
//  ============

CPQDIF_Info::CPQDIF_Info()
    {
    NI_Tag      nameTag;
    NI_ID_GUID  nameGuid;
    NI_ID_Int   nameInt;
    NI_Type     nameType;

    //  Treat the 'blank' tag a little differently
    nameTag.m_tag = tagBlank;
    nameTag.m_name = "< Blank >";
    m_listTags.push_back( nameTag );

    //  Tag names
#include "name_tag.inc"

    //  ID names
#include "name_id.inc"

    //  Physical type names
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_BOOLEAN1 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_BOOLEAN2 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_BOOLEAN4 );

    ADD_TYPE_ENTRY( ID_PHYS_TYPE_CHAR1 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_CHAR2 );

    ADD_TYPE_ENTRY( ID_PHYS_TYPE_INTEGER1 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_INTEGER2 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_INTEGER4 );

    ADD_TYPE_ENTRY( ID_PHYS_TYPE_UNS_INTEGER1 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_UNS_INTEGER2 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_UNS_INTEGER4 );

    ADD_TYPE_ENTRY( ID_PHYS_TYPE_REAL4 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_REAL8 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_COMPLEX8 );
    ADD_TYPE_ENTRY( ID_PHYS_TYPE_COMPLEX16 );

    ADD_TYPE_ENTRY( ID_PHYS_TYPE_TIMESTAMPPQDIF );

    ADD_TYPE_ENTRY( ID_PHYS_TYPE_GUID );

    return;
    }


CPQDIF_Info::~CPQDIF_Info()
    {
    }


const char * CPQDIF_Info::GetNameOfTag( const GUID& tag )
    {
    static  char *  nothing = "< Unrecognized >";
    const   char *  name = nothing;
    CList_NI_Tag::iterator  iter;

    for( iter = m_listTags.begin(); 
            iter != m_listTags.end();
            ++iter )
    {
        //  Matched tag?
        if( iter->m_tag == tag )
        {
            name = iter->m_name;
            break;
        }
    }

    return name;
    }


const char * CPQDIF_Info::GetNameOfPhysType( INT4 type )
    {
    static  char *  nothing = "< Unrecognized >";
    const   char *  name = nothing;    
    CList_NI_Type::iterator     iter;

    for( iter = m_listTypes.begin(); 
            iter != m_listTypes.end();
            ++iter )
    {
        //  Matched tag?
        if( iter->m_type == (int) type )
        {
            name = iter->m_name;
            break;
        }
    }

    return name;
    }


SIZE4 CPQDIF_Info::GetNumBytesOfType( int idType )
    {
    SIZE4   rc = 1L;

    switch (idType)
        {
        case ID_PHYS_TYPE_BOOLEAN1:
        case ID_PHYS_TYPE_CHAR1:
        case ID_PHYS_TYPE_INTEGER1:
        case ID_PHYS_TYPE_UNS_INTEGER1:
            rc = 1;
            ASSERT( rc == sizeof( BOOL1 ) );
            ASSERT( rc == sizeof( CHAR1 ) );
            ASSERT( rc == sizeof( INT1 ) );
            ASSERT( rc == sizeof( UINT1 ) );
            break;
        
        case ID_PHYS_TYPE_BOOLEAN2:
        case ID_PHYS_TYPE_CHAR2:
        case ID_PHYS_TYPE_INTEGER2:
        case ID_PHYS_TYPE_UNS_INTEGER2:
            rc = 2;
            ASSERT( rc == sizeof( BOOL2 ) );
            ASSERT( rc == sizeof( CHAR2 ) );
            ASSERT( rc == sizeof( INT2 ) );
            ASSERT( rc == sizeof( UINT2 ) );
            break;
        
        case ID_PHYS_TYPE_BOOLEAN4:
        case ID_PHYS_TYPE_INTEGER4:
        case ID_PHYS_TYPE_UNS_INTEGER4:
        case ID_PHYS_TYPE_REAL4:
            rc = 4;
            ASSERT( rc == sizeof( BOOL4 ) );
            ASSERT( rc == sizeof( INT4 ) );
            ASSERT( rc == sizeof( UINT4 ) );
            ASSERT( rc == sizeof( REAL4 ) );
            break;
        
        case ID_PHYS_TYPE_REAL8:
        case ID_PHYS_TYPE_COMPLEX8:
            rc = 8;
            ASSERT( rc == sizeof( REAL8 ) );
            ASSERT( rc == sizeof( COMPLEX8 ) );
            break;
        
        case ID_PHYS_TYPE_COMPLEX16:
            rc = 16;
            ASSERT( rc == sizeof( COMPLEX16 ) );
            break;

        case ID_PHYS_TYPE_TIMESTAMPPQDIF:
            rc = 12;
            ASSERT( rc == sizeof( TIMESTAMPPQDIF ) );
            break;

        case ID_PHYS_TYPE_GUID:
            rc = 16;
            ASSERT( rc == sizeof( GUID ) );
            break;

        default:
            rc = 1L;
            break;
        }
    return rc;
    }


SIZE4 CPQDIF_Info::padSizeTo4Bytes( SIZE4 sizeOrig )
    {
    SIZE4   remainder;

    remainder = ( sizeOrig % 4 );

    //  Already multiple of 4?
    if( remainder == 0 )
        return sizeOrig;

    //  Pad it
    return sizeOrig + ( 4 - remainder );
    }


BYTE * CPQDIF_Info::GetPtrToDataValue( int typePhysical, PQDIFValue& value )
{
    BYTE * byte = _GetPtrToDataValue( typePhysical, value );
    return (BYTE *) byte;
}


const BYTE * CPQDIF_Info::GetPtrToDataValue( int typePhysical, const PQDIFValue& value )
{
    const BYTE * byte = (const BYTE *) _GetPtrToDataValue( typePhysical, value );
    return byte;
}


BYTE * CPQDIF_Info::_GetPtrToDataValue( int typePhysical, const PQDIFValue& value )
{
    BYTE *  pbyte = NULL;

    switch( typePhysical )
        {
        case ID_PHYS_TYPE_BOOLEAN1:
            pbyte = (BYTE *) &value.bool1;
            break;

        case ID_PHYS_TYPE_CHAR1:
            pbyte = (BYTE *) &value.char1;
            break;

        case ID_PHYS_TYPE_INTEGER1:
            pbyte = (BYTE *) &value.int1;
            break;

        case ID_PHYS_TYPE_UNS_INTEGER1:
            pbyte = (BYTE *) &value.uint1;
            break;

        case ID_PHYS_TYPE_BOOLEAN2:
            pbyte = (BYTE *) &value.bool2;
            break;

        case ID_PHYS_TYPE_CHAR2:
            pbyte = (BYTE *) &value.char2;
            break;

        case ID_PHYS_TYPE_INTEGER2:
            pbyte = (BYTE *) &value.int2;
            break;

        case ID_PHYS_TYPE_UNS_INTEGER2:
            pbyte = (BYTE *) &value.uint2;
            break;

        case ID_PHYS_TYPE_BOOLEAN4:
            pbyte = (BYTE *) &value.bool4;
            break;

        case ID_PHYS_TYPE_INTEGER4:
            pbyte = (BYTE *) &value.int4;
            break;

        case ID_PHYS_TYPE_UNS_INTEGER4:
            pbyte = (BYTE *) &value.uint4;
            break;

        case ID_PHYS_TYPE_REAL4:
            pbyte = (BYTE *) &value.real4;
            break;

        case ID_PHYS_TYPE_REAL8:
            pbyte = (BYTE *) &value.real8;
            break;

        case ID_PHYS_TYPE_COMPLEX8:
            pbyte = (BYTE *) &value.complex8;
            break;

        case ID_PHYS_TYPE_COMPLEX16:
            pbyte = (BYTE *) &value.complex16;
            break;

        case ID_PHYS_TYPE_TIMESTAMPPQDIF:
            pbyte = (BYTE *) &value.ts;
            break;

        case ID_PHYS_TYPE_GUID:
            pbyte = (BYTE *) &value.guid;
            break;

        default:
            pbyte = NULL;
            break;
        }

    return pbyte;
}


bool CPQDIF_Info::GetTagGUID( int index, GUID& guidTag )
    {
    bool        status = false;
    NI_Tag *    info;

    info = _LookupTag( index );
    if( info )
        {
        guidTag = info->m_tag;
        status = true;
        }

    return status;
    }


bool CPQDIF_Info::GetTagName( int index, string& nameTag )
    {
    bool        status = false;
    NI_Tag *    info;

    info = _LookupTag( index );
    if( info )
        {
        nameTag = info->m_name;
        status = true;
        }

    return status;
    }


int CPQDIF_Info::GetIDCountGUID
            (
            const   GUID&   tagOwner
            )
{
    CList_NI_ID_GUID::iterator    iter;
    int countID = 0;

    for( iter = m_listGUIDs.begin(); 
            iter != m_listGUIDs.end();
            ++iter )
    {
        //  Matched class ID
        if( iter->m_tag == tagOwner )
        {
            countID++;
        }
    }

    return countID;
}


const char * CPQDIF_Info::GetIDNameGUID
            (
            const   GUID&   tagOwner,
                    int     idxID,
                    GUID&   valueID
            )
{
    NI_ID_GUID * info;
    const   char * name = NULL;
    
    info = _LookupGUID( tagOwner, idxID );
    if( info )
    {
        name = info->m_name;
        valueID = info->m_id;
    }

    return name;
}


int CPQDIF_Info::GetIDCountInt
            (
            const   GUID&   tagOwner
            )
{
    CList_NI_ID_Int::iterator    iter;
    int     countID = 0;

    for( iter = m_listInts.begin();
            iter != m_listInts.end();
            ++iter )
    {
        //  Matched class ID
        if( iter->m_tag == tagOwner )
        {
            countID++;
        }
    }

    return countID;
}


const char * CPQDIF_Info::GetIDNameInt
            (
            const   GUID&   tagOwner,
                    int     idxID,
                    int&    valueID
            )
{
    NI_ID_Int * info;
    const   char * name = NULL;
    
    info = _LookupInt( tagOwner, idxID );
    if( info )
    {
        name = info->m_name;
        valueID = info->m_id;
    }

    return name;
}


//  OPERATORS

bool operator == ( const NameInfo& obj1, const NameInfo& obj2 )
{
    if( obj1.m_name == obj2.m_name )
        return true;
    else
        return false;
}

bool operator != ( const NameInfo& obj1, const NameInfo& obj2 )
{
    if( obj1.m_name != obj2.m_name )
        return true;
    else
        return false;
}

bool operator < ( const NameInfo& obj1, const NameInfo& obj2 )
{
    if( obj1.m_name < obj2.m_name )
        return true;
    else
        return false;
}

bool operator > ( const NameInfo& obj1, const NameInfo& obj2 )
{
    if( obj1.m_name > obj2.m_name )
        return true;
    else
        return false;
}


//  Lookup functions
//  ----------------


NI_Tag * CPQDIF_Info::_LookupTag( int idxLook )
{
    CList_NI_Tag::iterator    iter;

    int         idxThis;
    NI_Tag *    info = NULL;

    for( iter = m_listTags.begin(), idxThis = 0; 
            iter != m_listTags.end();
            ++iter, idxThis++ )
    {
        //  Matched class ID
        if( idxThis == idxLook )
        {
            info = &(*iter);
            break;
        }
    }

    return info;
}


NI_ID_GUID * CPQDIF_Info::_LookupGUID
        (
        const   GUID&   tagOwner,
                int     idxLook 
        )
{
    CList_NI_ID_GUID::iterator    iter;

    int             idxThis;
    NI_ID_GUID *    info = NULL;

    idxThis = 0;
    for( iter = m_listGUIDs.begin(); 
            iter != m_listGUIDs.end();
            ++iter )
    {
        if( iter->m_tag == tagOwner )
        {
            //  Matched class ID
            if( idxThis == idxLook )
            {
                info = &(*iter);
                break;
            }
            idxThis++;
        }
    }

    return info;
}


NI_ID_Int * CPQDIF_Info::_LookupInt
        ( 
        const   GUID&   tagOwner,
                int     idxLook 
        )
{
    CList_NI_ID_Int::iterator    iter;

    int         idxThis;
    NI_ID_Int * info = NULL;

    idxThis = 0;
    for( iter = m_listInts.begin(); 
            iter != m_listInts.end();
            ++iter )
    {
        //  Matched owner?
        if( iter->m_tag == tagOwner )
        {
            if( idxThis == idxLook )
            {
                info = &(*iter);
                break;
            }
            idxThis++;
        }
    }

    return info;
}