sharedMemory.h

/*
** $RCSfile: sharedMemory.h $
** $Revision: 1.18 $
** $Author: doomer $
** $Date: 1996/05/09 18:12:12 $
** Copyright (c) 1996 John Dumais
*/

#if !defined(_veeSharedMemory_)
#define _veeSharedMemory_

#include <windows.h>
#include <string.h>
#include <stdlib.h>
#include "list.h"
#include "SWMRG.h"
#include "AdvWin32.H"

/********************************************************************
Manifest constant definitons
********************************************************************/

#define vErrorAlreadyExists 	-1
#define vErrorMapFailed			-2
#define vErrorListFailed		-3
#define vErrorAllocFailed		-4
#define vErrorGuardInitFailed	-5
#define vErrorWriteFailed		-6
#define vErrorReadFailed		-7
#define vErrorDataSize			-8
#define vErrorLockFailed		-9
#define vErrorUnknown			-100

/********************************************************************
Data type definitions
********************************************************************/

enum DataType{
	TypeLong,					/* 0 */
	TypeShort,					/* 1 */
	TypeFloat,					/* 2 */	
	TypeDouble,					/* 3 */
	TypeString					/* 4 */
};

struct VeeSharedDataInfo{
	char *segmentName;
	HANDLE segmentHandle;
	long nDataElements;
	LPVOID baseAddr;
	enum DataType dataType;
	SWMRG sharedMemoryGuard;
};

/********************************************************************
Prototypes for exported functions
********************************************************************/

long createLongShare(char *segmentName, long nLongs);
long createShortShare(char *segmentName, long nShorts);
long createFloatShare(char *segmentName, long nFloats);
long createDoubleShare(char *segmentName, long nDoubles);

long openLongShare(char *segmentName, long nLongs);
long openShortShare(char *segmentName, long nShorts);
long openFloatShare(char *segmentName, long nFloats);
long openDoubleShare(char *segmentName, long nDoubles);

long writeLongData(char *segmentName, long *data, long nLongs);
long writeShortData(char *segmentName, short *data, long nShorts);
long writeFloatData(char *segmentName, float *data, long nFloats);
long writeDoubleData(char *segmentName, double *data, long nDoubles);

long readLongData(char *segmentName, long *data, long nLongs);
long readShortData(char *segmentName, short *data, long nShorts);
long readFloatData(char *segmentName, float *data, long nFloats);
long readDoubleData(char *segmentName, double *data, long nDoubles);

long destroySharedMemory(char *segmentName);
long destroyAllSharedMemory(void);

long numberOfSegments(void);
long enumerateSharedMemory(char **segmentNames,
	long *nElements,
	short *dataType,
	long nEntries);

void setTimeOut(long timeValue);

char *revInfo(void);

/********************************************************************
Prototypes for functions used internally in the library
********************************************************************/

short openSharedMemory(char *segmentName,
	enum DataType type,
	long nElements,
	BOOL openExisting);
						 
BOOL compareSegName(void *nodeData, void *cmpData);

short segmentIsInList(char *segmentName,
	enum DataType type,
	long nElements);
					  
short createMappedSegment(struct VeeSharedDataInfo *segmentEntry);
short openMappedSegment(struct VeeSharedDataInfo *segmentEntry);
BOOL removeMappedSegment(struct VeeSharedDataInfo *segmentEntry);

BOOL initializeReadWriteGuard(struct VeeSharedDataInfo *segmentEntry);
BOOL openReadWriteGuard(struct VeeSharedDataInfo *segmentEntry);
void destroyReadWriteGuard(struct VeeSharedDataInfo *segmentEntry);

void numSegments(void *nodeData);
void enumerateSegments(void *nodeData);

long allocatedSize(struct VeeSharedDataInfo *segmentEntry);

long getWriteLock(struct VeeSharedDataInfo *segementEntry);
long getReadLock(struct VeeSharedDataInfo *segementEntry);
long lockResult(DWORD waitResult);

long writeSegment(char *segmentName, void *data, size_t dataSize);
long readSegment(char *segmentName, void *data, size_t dataSize);
	
#endif

/*
** $Log: sharedMemory.h $
** Revision 1.18  1996/05/09 18:12:12  doomer
** fixed an include
** Revision 1.17  1996/02/02 16:29:18  doomer
** removed prototype for unimplemented functions
** Revision 1.16  1996/02/02 09:51:52  doomer
** cleaned up some segmentation faults.
** Revision 1.15  1996/02/01 11:53:20  doomer
** first time I git round trip with locking working
** Revision 1.14  1996/01/31 16:08:48  doomer
** pointed the segment guards to occupy the top of the shared segement.
** read/write access to shared data looks one byte beyond the size
** of the shared segment guard
** did this so that another process can look at the handles to get read
** and write lockes.  dunno if this works.
** Revision 1.13  1996/01/31 13:16:18  doomer
** added prototype for numberOfSegments() & enumerateSharedMemory().
** Revision 1.12  1996/01/30 17:59:06  doomer
** added copyright information.
** Revision 1.11  1996/01/30 17:43:04  doomer
** added stuff to write to a shared memory segment.
** Revision 1.10  1996/01/30 15:57:46  doomer
** rearranged stuff to make it easier to read.
** Revision 1.9  1996/01/29 18:05:04  doomer
** added revInfo() function
** Revision 1.8  1996/01/29 17:27:26  doomer
** changed prototype for  removeMappedSegment() to take 
** struct VeeSharedDataInfo *segmentEntry as an argument.
** Revision 1.7  1996/01/29 16:55:12  doomer
** added proptotype for removeMappedSegment().
** Revision 1.6  1996/01/29 14:58:18  doomer
** gutted stuff to make this library depend on list.dll for its list management
** compiled all the stuff to add a shared memory segement.
** Revision 1.5  1995/12/29 18:12:38  doomer
** removed references to lastEntry from removeFromList() & destroySharedMemory().
** in removeSharedMemory(), adjusted the list head pointer in the case where
** I wanted to remove the first entry (which could, by definition be the
** last entry) in the list.
** Revision 1.4  1995/12/29 17:47:32  doomer
** added HANDLE segmentHandle to struct veeSharedDataInfo
** added BOOL *lastEntry to removeFromList().  This is to let the calling
** function know that the laste entry in the list has been removed
** changed return type from isInList() to struct veeSharedDataInfo.
** Revision 1.3  1995/12/29 16:18:32  doomer
** added #include of stdlib.h
** Revision 1.2  1995/12/29 15:40:06  doomer
** added #include of windows.h & string.h
** Revision 1.1  1995/12/29 15:31:34  doomer
** Initial revision
*/