/usr/include/wombat-c/destroyHandle.h is in libmama-dev 2.2.2.1-11.1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | /* $Id$
*
* OpenMAMA: The open middleware agnostic messaging API
* Copyright (C) 2011 NYSE Technologies, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301 USA
*/
#ifndef DESTROYHANDLE_H
#define DESTROYHANDLE_H
/* The destroy handle is used where there are multiple threads using a single
* resource which is needed until all threads have ended. The problem with this
* scenario is knowing when to destroy the object. If the owner thread deletes
* the object then other threads may in-advertantly access it despite the memory
* being freed.
* A destroy handle contains a reference to the object and a count of the number
* of outstanding threads. The destroy handle will only be destroyed once the object
* itself has been destroyed and all threads have finished using it. This means that
* although the object may be gone the thread will have valid memory to access.
*/
#if defined(__cplusplus)
extern "C" {
#endif
/* ************************************************************** */
/* Includes. */
/* ************************************************************** */
#include <stdlib.h>
#include "wlock.h"
/* ************************************************************** */
/* Structures. */
/* ************************************************************** */
/* This structure is used to track the number of open references to the owner
* object.
*/
typedef struct wDestroyHandle
{
/* This flag indicates if the owner has been destroyed. */
int m_destroyed;
/* The lock protects access to this structure. */
wLock m_lock;
/* This is the number of references that are held to the owner. */
long m_numberReferences;
/* A reference to the owner object, this will point to invalid
* memory if m_destroyed is set.
*/
void *m_owner;
} wDestroyHandle, * pDestroyHandle;
/* ********************************************************** */
/* Function Prototypes. */
/* ********************************************************** */
/**
* This function will create a new destroy handle and save a reference
* to the owner.
*
* @param[in] owner The owner object.
* @return The destroy handle or NULL on failure.
*/
COMMONExpDLL
extern
pDestroyHandle
destroyHandle_create(
void *owner);
/**
* This function must be called whenever the owner is destroyed. Note that the
* memory for the destroy handle won't be released until the owner is destroyed
* and the reference count reaches zero.
*
* @param[in] handle The destroy handle.
*/
COMMONExpDLL
extern
void
destroyHandle_destroyOwner(
pDestroyHandle handle);
/**
* This function must be called each time a reference to the destroy handle is passed
* to another thread. This should be matched by a corresponding call to
* destroyHandle_removeReference when the thread no longer needs the destroy handle.
*
* @param[in] handle The destroy handle.
*/
COMMONExpDLL
extern
void
destroyHandle_incrementRefCount(
pDestroyHandle handle);
/**
* This function must be called whenever a thread has finished using the destroy handle.
* It will return a reference to the owner object and will decrement the reference count.
* If the count has reached zero and the owner object has been destroyed then the destroy
* handle will be deleted.
*
* @param[in] handle The destroy handle.
* @return The owner object or NULL will be returned if the owner has been destroyed.
*/
COMMONExpDLL
extern
void *
destroyHandle_removeReference(
pDestroyHandle handle);
#if defined(__cplusplus)
}
#endif
#endif
|