181 lines
4.4 KiB
C++
181 lines
4.4 KiB
C++
#include "precomp.h"
|
|
#include "fsdiag.h"
|
|
DEBUG_FILEZONE(ZONE_T120_CONF_ROSTER);
|
|
/*
|
|
* crostmsg.cpp
|
|
*
|
|
* Copyright (c) 1995 by DataBeam Corporation, Lexington, KY
|
|
*
|
|
* Abstract:
|
|
* This is the implementation file for the Conference Roster Message
|
|
* Class. This class maintains a conference roster, and is able
|
|
* to "serialize" the roster into a block of memory. It utilizes a
|
|
* "Lock - UnLock" facility to ensure that the roster memory remains
|
|
* valid until all interested parties are through using the object.
|
|
*
|
|
* Protected Instance Variables:
|
|
*
|
|
* Private Member Functions:
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*
|
|
* Author:
|
|
* jbo/blp
|
|
*/
|
|
|
|
#include "crostmsg.h"
|
|
|
|
/*
|
|
* CConfRosterMsg ()
|
|
*
|
|
* Public Function Description
|
|
* This constructor is used to create a Conference Roster Message object.
|
|
* The pointer to the conference roster will be stored.
|
|
*/
|
|
CConfRosterMsg::CConfRosterMsg(CConfRoster *conference_roster)
|
|
:
|
|
CRefCount(MAKE_STAMP_ID('A','R','M','g')),
|
|
m_pMemoryBlock(NULL),
|
|
m_pConfRoster(conference_roster)
|
|
{
|
|
}
|
|
|
|
/*
|
|
* ~CConfRosterMsg ()
|
|
*
|
|
* Public Function Description:
|
|
* The destructor for the CConfRosterMsg class will clean up
|
|
* any memory allocated during the life of the object.
|
|
*/
|
|
CConfRosterMsg::~CConfRosterMsg(void)
|
|
{
|
|
delete m_pMemoryBlock;
|
|
}
|
|
|
|
/*
|
|
* GCCError LockConferenceRosterMessage ()
|
|
*
|
|
* Public Function Description
|
|
* This routine is used to lock an CConfRosterMsg. The memory
|
|
* necessary to hold the list of rosters is allocated and the rosters are
|
|
* "serialized" into the allocated memory block.
|
|
*/
|
|
GCCError CConfRosterMsg::LockConferenceRosterMessage(void)
|
|
{
|
|
GCCError rc = GCC_NO_ERROR;
|
|
UINT roster_data_length;
|
|
PGCCConferenceRoster temporary_roster;
|
|
|
|
/*
|
|
* Return an error if this object has been freed or if the internal
|
|
* conference roster pointer is invalid.
|
|
*/
|
|
if (m_pConfRoster == NULL)
|
|
return (GCC_ALLOCATION_FAILURE);
|
|
|
|
/*
|
|
* If this is the first time this routine is called, determine the size of
|
|
* the memory required to hold the conference roster and go ahead
|
|
* and serialize the data. Otherwise, just increment the lock count.
|
|
*/
|
|
if (Lock() == 1)
|
|
{
|
|
/*
|
|
* Determine the size of the memory block needed to hold the roster.
|
|
*/
|
|
roster_data_length = m_pConfRoster->LockConferenceRoster();
|
|
|
|
/*
|
|
* Allocate space to hold the conference roster and all associated data.
|
|
* FIX: Switch critical flag to TRUE when Sharded memory manager is
|
|
* set up to support it.
|
|
*/
|
|
DBG_SAVE_FILE_LINE
|
|
if (NULL != (m_pMemoryBlock = new BYTE[roster_data_length]))
|
|
{
|
|
/*
|
|
* Retrieve all of the data for the conference roster.
|
|
*/
|
|
m_pConfRoster->GetConfRoster(&temporary_roster, m_pMemoryBlock);
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("CConfRosterMsg::LockConferenceRosterMessage: "
|
|
"can't allocate memory, size=%u", (UINT) roster_data_length));
|
|
rc = GCC_ALLOCATION_FAILURE;
|
|
}
|
|
|
|
/*
|
|
* Since we do not need the conference roster anymore it is
|
|
* OK to unlock it here.
|
|
*/
|
|
m_pConfRoster->UnLockConferenceRoster ();
|
|
}
|
|
|
|
if (GCC_NO_ERROR != rc)
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* GCCError GetConferenceRosterMessage()
|
|
*
|
|
* Public Function Description
|
|
* This routine is used to obtain a pointer to the Conference Roster
|
|
* memory block used to deliver messages. This routine should not be
|
|
* called before LockConferenceRosterMessage is called.
|
|
*/
|
|
GCCError CConfRosterMsg::GetConferenceRosterMessage(LPBYTE *ppRosterData)
|
|
{
|
|
GCCError rc = GCC_ALLOCATION_FAILURE;
|
|
|
|
if (GetLockCount() > 0)
|
|
{
|
|
if (m_pMemoryBlock != NULL)
|
|
{
|
|
*ppRosterData = m_pMemoryBlock;
|
|
rc = GCC_NO_ERROR;
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("CConfRosterMsg::GetConferenceRosterMessage: no data"));
|
|
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("CConfRosterMsg::GetConferenceRosterMessage: data not locked"));
|
|
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* void UnLockConferenceRosterMessage ()
|
|
*
|
|
* Public Function Description
|
|
* This member function is responsible for unlocking the data locked for
|
|
* the "API" conference roster after the lock count goes to zero.
|
|
*/
|
|
void CConfRosterMsg::UnLockConferenceRosterMessage(void)
|
|
{
|
|
if (Unlock(FALSE) == 0)
|
|
{
|
|
/*
|
|
* Free up the memory block allocated to hold the roster
|
|
*/
|
|
delete m_pMemoryBlock;
|
|
m_pMemoryBlock = NULL;
|
|
}
|
|
|
|
// we have to call Release() because we used Unlock(FALSE)
|
|
Release();
|
|
}
|
|
|
|
|