oaMapWindow.h

Go to the documentation of this file.

// *****************************************************************************
// oaMapWindow.h
//
// This file contains the definitions for the oaMapWindow and oaMapFileWindow
// classes.  These utility classes are used to read data from, and write data
// to, a memory-mapped disk file.
//
// Capabilities supported include:
//
// 1)   The oaMapWindow base class implements a memory-mapped window that is
//      independent of the underlying backing storage (which may be a regular
//      file, a shared memory segment or the OS pagefile).
// 2)   The oaMapFileWindow class derives from oaMapWindow, associating the
//      window with a oaMapFile as the backing storage. oaMapFileWindow
//      belongs to a linked list of all windows for a specific oaMapFile.
//      While its memory-mapped window is closed, an existing oaMapFileWindow
//      object can switch to map a different oaMapFile.
// 3)   The oaMapFileWindow supports byte-swapping in order to support files
//      across machine types.
// 3)   These classes support files whose size is larger than 32 bits. As part
//      of this support, the API allows any 32-bit window of the file to be
//      mapped at a time.
//
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this material may not be copied, modified,
// re-published, uploaded, executed, or distributed in any way, in any medium,
// in whole or in part, without prior written permission from Cadence.
//
//                Copyright 2002-2005 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: icftcm $
//  $Revision: #1 $
//  $Date: 2010/08/09 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(oaMapWindow_P)
#define oaMapWindow_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaPackedData.h"
#include "oaMapFile.h"



// *****************************************************************************
// Declare and define types in the OpenAccess namespace.
// *****************************************************************************
BEGIN_OA_NAMESPACE



// *****************************************************************************
// Forward Public Class Declarations
// *****************************************************************************
class oaMapFile;



// *****************************************************************************
// oaMapWindow
// *****************************************************************************
class OA_BASE_DLL_API oaMapWindow {
public:
                            oaMapWindow(oaByte  *dataIn,
                                        oaUInt4 sizeIn,
                                        oaUInt8 offsetIn);
    virtual                 ~oaMapWindow();

    oaBoolean               isMapped() const;
    oaBoolean               isMapped(oaUInt4    sizeIn,
                                     oaUInt8    offsetIn,
                                     oaUInt4    &loc) const;

    oaUInt4                 getSize() const;
    oaUInt8                 getOffset() const;
    oaUInt4                 getLoc(oaUInt8 offsetIn) const;

    oaByte                  &operator[](oaUInt4 index);

    oaByte                  *getBytes(oaUInt4 loc) const;

    const oaPackedData      &data() const;

protected:
    oaByte                  *dataP;
    oaUInt8                 offset;
    oaUInt4                 size;

    oaPackedData            packedData;
};



// *****************************************************************************
// oaMapFileWindow
// *****************************************************************************
class OA_BASE_DLL_API oaMapFileWindow : public oaMapWindow {
public:

                            oaMapFileWindow(oaMapFile &mapFileIn);
                            oaMapFileWindow(oaByte      *dataIn,
                                            oaUInt4     sizeIn,
                                            oaUInt8     offsetIn,
                                            oaMapFile   &mapFileIn);

    virtual                 ~oaMapFileWindow();

    void                    map(oaUInt4 sizeIn = 0,
                                oaUInt8 offsetIn = 0,
                                void    *mapLoc = NULL);

    void                    unmap();

    oaUInt4                 move(oaUInt4    sizeIn,
                                 oaUInt8    offsetIn,
                                 oaBoolean  resize = false);
    oaUInt4                 extend(oaUInt4 sizeIn);

    oaMapFile               &getMapFile();
    const oaMapFile         &getMapFile() const;
    oaMapFileWindow         *getNext() const;

    void                    setMapFile(oaMapFile &mapFileIn);
    void                    reset();

    void                    writeSwapCheck(oaUInt4 &loc);
    void                    readSwapCheck(oaUInt4 &loc);

    oaBoolean               getSwap() const;

protected:
    void                    setNext(oaMapFileWindow *nextIn);

    void                    setSwap(oaBoolean swap);

    oaMapFile               *mapFile;
    oaMapFileWindow         *next;

    static const oaUInt4    swapTestInt;

    friend class oaMapFile;
};



END_OA_NAMESPACE

#endif

Return to top of page

Copyright © 2002 - 2010 Cadence Design Systems, Inc.
All Rights Reserved.