cpgpdiskengine.h

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

}

inline 
void 
CPGPdiskUser::SetIsLocked(PGPBoolean isLocked)
{
	pgpAssert(IsAttached());
	SetBooleanProp(kPGPdiskUserProp_IsLocked, isLocked);
}

inline 
void 
CPGPdiskUser::SetIsDisabled(PGPBoolean isDisabled)
{
	pgpAssert(IsAttached());
	SetBooleanProp(kPGPdiskUserProp_IsDisabled, isDisabled);
}

inline 
void 
CPGPdiskUser::SetUserName(const char *userName)
{
	pgpAssert(IsAttached());
	SetDataProp(kPGPdiskUserProp_UserName, userName, strlen(userName));
}

inline 
void 
CPGPdiskUser::EnableCiphering(PGPdiskDiskRef disk, const char *passphrase, int passkeylen)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskUserEnableCiphering(mUser, disk, passphrase, passkeylen);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUser::DisableCiphering()
{
	pgpAssert(IsAttached());
	PGPdiskUserDisableCiphering(mUser);
}

inline 
void 
CPGPdiskUser::ChangePassphrase(const char * newPassphrase)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskUserChangePassphrase(mUser, newPassphrase);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUser::Create(
	PGPdiskUserRef	cipheringUser, 
	const char		*userName, 
	const char		*passphrase, 
	PGPBoolean		isReadOnly)
{
	pgpAssert(!IsAttached());

	PGPError	error	= PGPdiskNewUserWithSymmetricKey(cipheringUser, 
		userName, passphrase, isReadOnly, &mUser);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUser::Create(
	PGPdiskUserRef	cipheringUser, 
	PGPKeyDBObjRef	pubKey, 
	PGPBoolean		isReadOnly, 
	PGPBoolean		isLocked)
{
	pgpAssert(!IsAttached());

	PGPError	error	= PGPdiskNewUserWithPublicKey(cipheringUser, pubKey, 
		isReadOnly, isLocked, &mUser);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUser::DuplicateUser(PGPdiskUserRef user)
{
	pgpAssert(!IsAttached());

	PGPError	error	= PGPdiskDuplicateUser(user, &mUser);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUser::Attach(PGPdiskUserRef user)
{
	if (mUser == user)
		return;

	Clear();

	mUser = user;
	mWeCreated = FALSE;
}

inline 
void 
CPGPdiskUser::Clear()
{
	if (WeCreated())
		PGPdiskFreeUser(mUser);

	mUser = kInvalidPGPdiskUserRef;
	mWeCreated = FALSE;
}

inline 
PGPBoolean 
CPGPdiskUser::GetBooleanProp(PGPdiskUserPropName prop) const
{
	pgpAssert(IsAttached());

	PGPBoolean	boolVal;

	PGPError	error	= PGPdiskGetUserBooleanProp(mUser, prop, &boolVal);
	THROW_IF_PGPERROR(error);

	return boolVal;
}

inline 
PGPInt32 
CPGPdiskUser::GetNumericProp(PGPdiskUserPropName prop) const
{
	pgpAssert(IsAttached());

	PGPInt32	number;

	PGPError	error	= PGPdiskGetUserNumericProp(mUser, prop, &number);
	THROW_IF_PGPERROR(error);

	return number;
}

inline 
void 
CPGPdiskUser::GetDataProp(
	PGPdiskUserPropName	prop, 
	void				*pData, 
	PGPSize				availLength, 
	PGPSize				*pUsedLength) const
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskGetUserDataProp(mUser, prop, pData, 
		availLength, pUsedLength);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUser::SetBooleanProp(PGPdiskUserPropName prop, PGPBoolean boolVal)
{
	PGPError	error	= PGPdiskSetUserBooleanProp(mUser, prop, boolVal);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUser::SetNumericProp(PGPdiskUserPropName prop, PGPInt32 number)
{
	PGPError	error	= PGPdiskSetUserNumericProp(mUser, prop, number);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUser::SetDataProp(
	PGPdiskUserPropName	prop, 
	const void			*pData, 
	PGPSize				length)
{
	PGPError	error	= PGPdiskSetUserDataProp(mUser, prop, pData, length);
	THROW_IF_PGPERROR(error);
}


// Class CPGPdiskUserSet member functions

inline 
CPGPdiskUserSet::CPGPdiskUserSet() : 
	mUserSet(kInvalidPGPdiskUserSetRef), mWeCreated(FALSE)
{
	CreateEmpty();
}

inline 
CPGPdiskUserSet::CPGPdiskUserSet(PGPdiskUserRef user) : 
	mUserSet(kInvalidPGPdiskUserSetRef), mWeCreated(FALSE)
{
	CreateSingleton(user);
}

inline 
CPGPdiskUserSet::CPGPdiskUserSet(PGPdiskUserSetRef userSet) : 
	mUserSet(kInvalidPGPdiskUserSetRef), mWeCreated(FALSE)
{
	Attach(userSet);
}

inline 
CPGPdiskUserSet::~CPGPdiskUserSet()
{
	try
	{
		Clear();
	}
	catch (PGPError&) { }
}

inline 
PGPBoolean 
CPGPdiskUserSet::IsAttached() const
{
	return PGPdiskUserSetRefIsValid(mUserSet);
}

inline 
PGPUInt32 
CPGPdiskUserSet::Count() const
{
	pgpAssert(IsAttached());
	return PGPdiskUserSetCount(mUserSet);
}

inline 
void 
CPGPdiskUserSet::Add(PGPdiskUserSetRef usersToAdd)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskUserSetAddUsers(mUserSet, usersToAdd);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUserSet::Add(PGPdiskUserRef userToAdd)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskUserSetAddUser(mUserSet, userToAdd);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUserSet::Remove(PGPdiskUserSetRef usersToRemove)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskUserSetRemoveUsers(mUserSet, usersToRemove);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUserSet::Remove(PGPdiskUserRef userToRemove)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskUserSetRemoveUser(mUserSet, userToRemove);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUserSet::Empty()
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskUserSetEmptyUserSet(mUserSet);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUserSet::Attach(PGPdiskUserSetRef userSet)
{
	if (mUserSet == userSet)
		return;

	Clear();

	mUserSet = userSet;
	mWeCreated = FALSE;
}

inline 
void 
CPGPdiskUserSet::CreateEmpty()
{
	Clear();

	PGPError	error	= PGPdiskNewUserSet(&mUserSet);
	THROW_IF_PGPERROR(error);

	mWeCreated = TRUE;
}

inline 
void 
CPGPdiskUserSet::CreateSingleton(PGPdiskUserRef user)
{
	Clear();

	PGPError	error	= PGPdiskNewSingletonUserSet(user, &mUserSet);
	THROW_IF_PGPERROR(error);

	mWeCreated = TRUE;
}

inline 
void 
CPGPdiskUserSet::Clear()
{
	if (WeCreated())
		PGPdiskFreeUserSet(mUserSet);

	mUserSet = kInvalidPGPdiskUserSetRef;
	mWeCreated = FALSE;
}


// Class CPGPdiskUserIter member functions

inline 
CPGPdiskUserIter::CPGPdiskUserIter(PGPdiskUserSetRef userSet) : 
	mUserIter(kInvalidPGPdiskUserIterRef), mWeCreated(FALSE)
{
	Create(userSet);
}

inline 
CPGPdiskUserIter::CPGPdiskUserIter(PGPdiskUserIterRef userIter) : 
	mUserIter(kInvalidPGPdiskUserIterRef), mWeCreated(FALSE)
{
	Attach(userIter);
}

inline 
CPGPdiskUserIter::~CPGPdiskUserIter()
{
	try
	{
		Clear();
	}
	catch (PGPError&) { }
}

inline 
PGPdiskUserSetRef 
CPGPdiskUserIter::UserSet() const
{
	pgpAssert(IsAttached());
	return PGPdiskPeekUserIterUserSet(mUserIter);
}

inline 
PGPBoolean 
CPGPdiskUserIter::IsAttached() const
{
	return PGPdiskUserIterRefIsValid(mUserIter);
}

inline 
PGPUInt32 
CPGPdiskUserIter::Count() const
{
	pgpAssert(IsAttached());
	return PGPdiskUserIterCount(mUserIter);
}

inline 
PGPInt32 
CPGPdiskUserIter::Index() const
{
	pgpAssert(IsAttached());
	return PGPdiskUserIterIndex(mUserIter);
}

inline 
PGPBoolean 
CPGPdiskUserIter::Current(CPGPdiskUser& user) const
{
	pgpAssert(IsAttached());

	PGPdiskUserRef	userRef;
	PGPBoolean		succeeded	= PGPdiskUserIterUser(mUserIter, &userRef);

	if (succeeded)
		user = userRef;

	return succeeded;
}

inline 
PGPBoolean 
CPGPdiskUserIter::Move(
	PGPInt32		relOffset, 
	PGPBoolean		fromStart, 
	CPGPdiskUser&	user)
{
	pgpAssert(IsAttached());

	PGPdiskUserRef	userRef;
	PGPBoolean		succeeded	= PGPdiskUserIterMove(mUserIter, relOffset, 
		fromStart, &userRef);

	if (succeeded)
		user = userRef;

	return succeeded;
}

inline 
PGPInt32 
CPGPdiskUserIter::Seek(PGPdiskUserRef soughtUser)
{
	pgpAssert(IsAttached());
	return PGPdiskUserIterSeek(mUserIter, soughtUser);
}

inline 
PGPBoolean 
CPGPdiskUserIter::Next(CPGPdiskUser& user)
{
	pgpAssert(IsAttached());

	PGPdiskUserRef	userRef;
	PGPBoolean		succeeded	= PGPdiskUserIterNext(mUserIter, &userRef);

	if (succeeded)
		user = userRef;

	return succeeded;
}

inline 
PGPBoolean 
CPGPdiskUserIter::Prev(CPGPdiskUser& user)
{
	pgpAssert(IsAttached());

	PGPdiskUserRef	userRef;
	PGPBoolean		succeeded	= PGPdiskUserIterPrev(mUserIter, &userRef);

	if (succeeded)
		user = userRef;

	return succeeded;
}

inline 
void 
CPGPdiskUserIter::Rewind()
{
	pgpAssert(IsAttached());
	PGPdiskUserIterRewind(mUserIter);
}

inline 
PGPBoolean 
CPGPdiskUserIter::SearchOnUserName(const char *userName, CPGPdiskUser& user)
{
	pgpAssert(IsAttached());

	PGPdiskUserRef	userRef;
	PGPBoolean		succeeded	= PGPdiskUserIterSearchOnUserName(mUserIter, 
		userName, &userRef);

	if (succeeded)
		user = userRef;

	return succeeded;
}

inline 
PGPBoolean 
CPGPdiskUserIter::FindEqualUser(
	const CPGPdiskUser&	user, 
	CPGPdiskUser&		equalUser)
{
	pgpAssert(IsAttached());

	PGPdiskUserRef	userRef;
	PGPBoolean		succeeded	= PGPdiskUserIterFindEqualUser(mUserIter, 
		user, &userRef);

	if (succeeded)
		equalUser = userRef;

	return succeeded;
}

inline 
PGPBoolean 
CPGPdiskUserIter::FindAdminUser(CPGPdiskUser& user)
{
	pgpAssert(IsAttached());

	PGPdiskUserRef	userRef;
	PGPBoolean		succeeded	= PGPdiskUserIterFindAdminUser(mUserIter, 
		&userRef);

	if (succeeded)
		user = userRef;

	return succeeded;
}

inline 
void 
CPGPdiskUserIter::SetAdminUser(
	PGPdiskUserRef userForCiphering, 
	PGPdiskUserRef oldAdminForCiphering)
{
	pgpAssert(IsAttached());

	PGPError	error	= PGPdiskUserIterSetAdminUser(mUserIter, 
		userForCiphering, oldAdminForCiphering);
	THROW_IF_PGPERROR(error);
}

inline 
void 
CPGPdiskUserIter::Attach(PGPdiskUserIterRef userIter)
{
	if (mUserIter == userIter)
		return;

	Clear();

	mUserIter = userIter;
	mWeCreated = FALSE;
}

inline 
void 
CPGPdiskUserIter::Create(PGPdiskUserSetRef userSet)
{
	Clear();

	PGPError	error	= PGPdiskNewUserIter(userSet, &mUserIter);
	THROW_IF_PGPERROR(error);

	mWeCreated = TRUE;
}

inline 
void 
CPGPdiskUserIter::Clear()
{
	if (WeCreated())
		PGPdiskFreeUserIter(mUserIter);

	mUserIter = kInvalidPGPdiskUserIterRef;
	mWeCreated = FALSE;
}

_PGP_END

#endif	// ] Included_CPGPdiskEngine_h