ElementIdMap.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once

#include    "DgnPlatform.h"

BEGIN_BENTLEY_DGNPLATFORM_NAMESPACE


//=======================================================================================
//=======================================================================================

template <class _ForeignId>  struct FixedSizeForeignIdIO
{
    StatusInt Store (_ForeignId const& id, DataExternalizer& sink)  { sink.put((UInt8 const*) &id, sizeof (id)); return SUCCESS;}
    StatusInt Load  (_ForeignId& id, DataInternalizer& source)      { source.get((UInt8*) &id, sizeof (id));  return SUCCESS;}
};


//=======================================================================================

template <class _ForeignId, 
          class _Compare = std::less<_ForeignId>,
          class _ForeignIdIO = FixedSizeForeignIdIO <_ForeignId> >  

class ElementIdMap
{

    bmap <_ForeignId, T_AUInt64,_Compare>  m_idMap;
    T_AUInt64                               m_highestId;
    mutable _ForeignIdIO                    m_io;

public:

     ElementIdMap (_ForeignIdIO const& io) : m_io (io), m_highestId (0) { }

/*---------------------------------------------------------------------------------**/
T_AUInt64    GetId (_ForeignId const& foreignId)
    {
    bmap <_ForeignId, T_AUInt64, _Compare>::const_iterator    found = m_idMap.find (foreignId);

    if (found != m_idMap.end())
        return found->second;

    return m_idMap[foreignId] = ++m_highestId;
    }

/*---------------------------------------------------------------------------------**/
StatusInt   Store (DataExternalizer& sink) const
    {
    for (bmap <_ForeignId, T_AUInt64, _Compare>::const_iterator curr = m_idMap.begin(); curr != m_idMap.end(); curr++)
        {
        sink.put (curr->second);
        m_io.Store (curr->first, sink);
        }
    return SUCCESS;
    }

/*---------------------------------------------------------------------------------**/
StatusInt   Load (DataInternalizer& source)
    {
    size_t      minimumIdSize = 2;
    size_t      minimumEntrySize = sizeof (T_AUInt64) + minimumIdSize;
    StatusInt   status = SUCCESS;


    source.rewind ();

    while (SUCCESS == status && source.getRemainingSize  () > sizeof (UInt32) + minimumEntrySize)
        {
        _ForeignId  foreignId;
        T_AUInt64   elementId;

        source.get (&elementId);
            
        if (SUCCESS == (status = m_io.Load (foreignId, source)))
            m_idMap[foreignId] = elementId;

        if (elementId > m_highestId)
            m_highestId = m_highestId;
            
        };
    return SUCCESS;
    }

/*---------------------------------------------------------------------------------**/
BeFileName     GetMapFileName (WStringCR baseName)
    {
    WString             device, dir, name, extension;
    BeFileName          mapFileName;

    BeFileName::ParseName (&device, &dir, &name, &extension, baseName.c_str());
    extension = extension + L".DgnIdMap";
    mapFileName.BuildName (device.c_str(), dir.c_str(), name.c_str(), extension.c_str());

    return mapFileName;
    }

/*---------------------------------------------------------------------------------**/
StatusInt   Load (WStringCR  baseFileName)
    {
    FILE*               mapFile;

    if (NULL == (mapFile = _wfopen (GetMapFileName (baseFileName), L"rb")))
        return ERROR;

    fseek (mapFile, 0, SEEK_END);  
    size_t      mapFileSize = ftell (mapFile);
    
    bvector<byte>       fileBuffer (mapFileSize);

    fseek (mapFile, 0, SEEK_SET);  
    size_t count = fread (&fileBuffer.front(), 1, mapFileSize, mapFile);

    BeAssert (count == mapFileSize);

    DataInternalizer    source (&fileBuffer.front(), mapFileSize);
    StatusInt   status = Load (source);

    fclose (mapFile);
    return status;
    }

/*---------------------------------------------------------------------------------**/
StatusInt   Store (WStringCR  baseFileName)
    {
    StatusInt               status;
    DataExternalizer        sink;

    if (SUCCESS != (status = Store (sink)))
        return status;

    if (sink.getBytesWritten() == 0)
        return ERROR;

    FILE*               mapFile;
    if (NULL == (mapFile = _wfopen (GetMapFileName (baseFileName), L"wb")))
        {
        BeAssert (false);
        return ERROR;
        }

    fwrite (sink.getBuf(), 1, sink.getBytesWritten(), mapFile);
    fclose (mapFile);
    return SUCCESS;
    }

};  //  ElementIdMap


//=======================================================================================
//=======================================================================================
struct WStringIdIO
{
    StatusInt Store (WStringCR id, DataExternalizer& sink)  { sink.put(id); return SUCCESS;}
    StatusInt Load  (WStringR id, DataInternalizer& source) { source.get(id);  return SUCCESS;}
};

typedef  ElementIdMap <WString, std::less<WString const&>, WStringIdIO> T_StringToElementIdMap;
//=======================================================================================
//=======================================================================================
struct StringToElementIdMap : T_StringToElementIdMap
{
    StringToElementIdMap () : T_StringToElementIdMap (WStringIdIO()) { }
};



END_BENTLEY_DGNPLATFORM_NAMESPACE