oaMapFile.h

Go to the documentation of this file.

// *****************************************************************************
// oaMapFile.h
//
// This file contains the definitions for the oaMapFile class. This utility
// class extend oaFile to manage a memory-mapped disk file. Capabilities
// supported include:
//
// 1)   The oaMapFile class implements the basic file-mapping capability,
//      which is used by oaMapFileWindow for each memory-mapped portion of the
//      file.
// 2)   The oaMapFile class supports byte-swapping in order to support files
//      across machine types.
// 3)   This class 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.
// 4)   Newly created files must be handled carefully, because zero sized files
//      cannot be mapped. For this reason, the mapping size is checked, and if
//      zero, the map is not created.
// 5)   oaMapFile supports changing the size of the underlying file while one
//      or more oaMapFileWindows are open, with the restriction that while
//      the file size is being changed by one thread, there must not be any
//      attempt by other threads to read or write to the file.
//
// Note that the Win32 and UNIX versions of this class are quite different due
// to the differences in how file mapping is supported.
//
// *****************************************************************************
// 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(oaMapFile_P)
#define oaMapFile_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaFile.h"



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



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



// *****************************************************************************
// oaMapFile
// *****************************************************************************
class OA_BASE_DLL_API oaMapFile : public oaFile {
public:
                            oaMapFile(const oaString &nameIn);
    virtual                 ~oaMapFile();

    oaByte                  *map(oaUInt4    &size,
                                 oaUInt8    &offset,
                                 void       *mapLoc = NULL);
    void                    unmap(oaByte    *mapLoc,
                                  oaUInt4   size);

    void                    setSize(oaUInt8 size);
    oaUInt8                 getMappableSize() const;

    oaMapFileWindow         *getFirstWindow() const;
    void                    closeWindows();

    oaBoolean               isMapped() const;

    oaBoolean               getSwap() const;
    void                    setSwap(oaBoolean swapIn);

protected:
    void                    initMapping(oaUInt8 size);
    void                    destroyMapping();

    void                    addWindow(oaMapFileWindow *window);
    void                    removeWindow(oaMapFileWindow *window);

    oaUInt8                 mappableSize;
    oaUInt4                 numMappedWindows;
    oaMapFileWindow         *firstWindow;
    oaBoolean               swap;

#if defined(OA_WINDOWS)
    // Note that we define a handle as a void* in order to avoid a dependency
    // on Windows.h in the public headers. The handle will be cast to the
    // correct type of HANDLE when used.
    void                    *mapHandle;
#endif

    static const oaUInt4    alignment;
    static const oaUInt4    granularity;

    friend class oaMapFileWindow;
};



END_OA_NAMESPACE

#endif

Return to top of page

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