pflprefs.c

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

				
			case kPGPPrefType_Byte:
				if (IsntNull(newElement->data))
				{
					if (IsntNull(copyElement->data) && !prefRef->dirty)
					{
						if (!pgpMemoryEqual(newElement->data, 
							copyElement->data, copyElement->size))
							prefRef->dirty = TRUE;
					}
					else
						prefRef->dirty = TRUE;
				}
				else if (IsntNull(copyElement->data))
					prefRef->dirty = TRUE;

				if (prefRef->dirty)
				{
					if (IsntNull(newElement->data))
						PGPFreeData(newElement->data);
					
					if (IsntNull(copyElement->data))
					{
						newElement->data = PGPNewData(prefRef->memoryMgr,
												newElement->size,
												kPGPMemoryMgrFlags_Clear);
						
						if (IsNull(newElement->data))
						{
							err = kPGPError_OutOfMemory;
							break;
						}
						
						pgpCopyMemory(copyElement->data, newElement->data,
							newElement->size);
					}
					else
						newElement->data = NULL; 
				}
				
				break;
				
			case kPGPPrefType_Struct:
				if (IsNull(newElement->data))
				{
					prefRef->dirty = TRUE;
					newElement->size = sizeof(PGPPrefStruct);
					newElement->data = PGPNewData(prefRef->memoryMgr,
											sizeof(PGPPrefStruct),
											kPGPMemoryMgrFlags_Clear);
				
					if (IsNull(newElement->data))
					{
						err = kPGPError_OutOfMemory;
						break;
					}
				}
				
				err = sCopyStructDataToPref(prefRef, FALSE,
						(PGPPrefStruct *) copyElement->data,
						(PGPPrefStruct *) newElement->data);
				break;

			default:
				break;
			}
		}
		break;

	default:
		break;
	}

	currentPrefData->dataLength = dataLength;
	return err;
}


PGPError PGPClearPrefData(PGPPrefRef prefRef, 
							PGPPrefIndex prefIndex)
{
	PGPPrefData *	currentPrefData;
	PGPPrefStruct *	tempStruct;
	PGPPrefArray *	tempArray;
	PGPError		err;
	
	PGPValidatePref(prefRef);

	err = sFindPrefDataByIndex(prefRef, prefIndex, &currentPrefData);
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	if (IsNull(currentPrefData))
		return kPGPError_PrefNotFound;

	prefRef->dirty = TRUE;

	switch (currentPrefData->prefType)
	{
	case kPGPPrefType_Boolean:
		currentPrefData->data.b = FALSE;
		break;

	case kPGPPrefType_Number:
		currentPrefData->data.i = 0;
		break;

	case kPGPPrefType_String:
	case kPGPPrefType_Byte:
		sFreePrefData(currentPrefData, FALSE);
		break;

	case kPGPPrefType_Struct:
		tempStruct = currentPrefData->data.strct;
		PGPCreatePrefStruct(prefRef, tempStruct, 
			&(currentPrefData->data.strct));
		PGPFreePrefStruct(tempStruct);
		break;

	case kPGPPrefType_Array:
		tempArray = currentPrefData->data.a;
		PGPCreatePrefArray(prefRef, tempArray->type, 0, 
			tempArray->templateStruct, &(currentPrefData->data.a));
		PGPFreePrefArray(tempArray);
		break;

	default:
		break;
	}

	return kPGPError_NoErr;
}


PGPError PGPRemovePref(PGPPrefRef prefRef, 
						   PGPPrefIndex prefIndex)
{
	PGPPrefData *	currentPrefData;
	PGPError		err;
	
	PGPValidatePref(prefRef);

	err = sFindPrefDataByIndex(prefRef, prefIndex, &currentPrefData);
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	if (IsNull(currentPrefData))
		return kPGPError_PrefNotFound;

	sRemovePrefData(prefRef, currentPrefData);
	prefRef->dirty = TRUE;
	return kPGPError_NoErr;
}


PGPError PGPCreatePrefStruct(PGPPrefRef prefRef,
								PGPPrefStruct *templateStruct,
								PGPPrefStruct **newStruct)
{
	PGPValidatePref(prefRef);

	return sCreatePrefStruct(prefRef->memoryMgr, templateStruct, newStruct);
}

static PGPError sCreatePrefStruct(PGPMemoryMgrRef memoryMgr,
									PGPPrefStruct *templateStruct,
									PGPPrefStruct **newStruct)
{
	PGPUInt32 index;

	if (IsntNull(newStruct))
		*newStruct = NULL;

	PGPValidatePtr(templateStruct);
	PGPValidatePtr(newStruct);
	PGPValidateParam(templateStruct->numMembers > 0);

	*newStruct = (PGPPrefStruct *) PGPNewData(memoryMgr,
										sizeof(PGPPrefStruct),
										kPGPMemoryMgrFlags_Clear);

	if (IsNull(*newStruct))
		return kPGPError_OutOfMemory;

	(*newStruct)->numMembers = templateStruct->numMembers;

	(*newStruct)->members = (PGPPrefStructMember *) 
								PGPNewData(memoryMgr,
									sizeof(PGPPrefStructMember) *
									templateStruct->numMembers,
									kPGPMemoryMgrFlags_Clear);

	if (IsNull((*newStruct)->members))
	{
		PGPFreeData(*newStruct);
		*newStruct = NULL;
		return kPGPError_OutOfMemory;
	}

	for (index=0; index<templateStruct->numMembers; index++)
	{
		(*newStruct)->members[index].type = 
			templateStruct->members[index].type;

		(*newStruct)->members[index].data = NULL;
		(*newStruct)->members[index].size = 0;
	}

	return kPGPError_NoErr;
}


PGPError PGPFreePrefStruct(PGPPrefStruct *prefStruct)
{
	PGPUInt32 index;

	PGPValidatePtr(prefStruct);
	
	pgpAssertMsg(!(prefStruct->dirty), "Pref struct data was"
		" changed, but changes were not saved with PGPSetPrefStruct");

	for (index=0; index<prefStruct->numMembers; index++)
	{
		switch (prefStruct->members[index].type)
		{
		case kPGPPrefType_String:
		case kPGPPrefType_Byte:
			if (IsntNull(prefStruct->members[index].data))
				PGPFreeData(prefStruct->members[index].data);
			break;

		default:
			break;
		}
	}
	
	PGPFreeData(prefStruct->members);
	PGPFreeData(prefStruct);
	
	return kPGPError_NoErr;
}


PGPError PGPCreatePrefArray(PGPPrefRef prefRef,
								PGPPrefType arrayType,
								PGPUInt32 arraySize,
								PGPPrefStruct *templateStruct,
								PGPPrefArray **prefArray)
{
	PGPError err = kPGPError_NoErr;

	if (IsntNull(prefArray))
		*prefArray = NULL;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);

	*prefArray = (PGPPrefArray *) PGPNewData(prefRef->memoryMgr,
										sizeof(PGPPrefArray),
										kPGPMemoryMgrFlags_Clear);

	if (IsNull(*prefArray))
		return kPGPError_OutOfMemory;

	(*prefArray)->numElements = arraySize;
	(*prefArray)->type = arrayType;
	(*prefArray)->dirty = FALSE;

	if (arraySize > 0)
	{
		(*prefArray)->elements = (PGPPrefArrayElement *) 
									PGPNewData(prefRef->memoryMgr,
										sizeof(PGPPrefArrayElement) *
										arraySize,
										kPGPMemoryMgrFlags_Clear);

		if (IsNull((*prefArray)->elements))
		{
			PGPFreeData(*prefArray);
			*prefArray = NULL;
			return kPGPError_OutOfMemory;
		}
	}

	if (arrayType == kPGPPrefType_Struct)
	{
		PGPValidatePtr(templateStruct);
		PGPValidateParam(templateStruct->numMembers > 0);

		(*prefArray)->templateStruct = (PGPPrefStruct *) 
										PGPNewData(prefRef->memoryMgr,
											sizeof(PGPPrefStruct),
											kPGPMemoryMgrFlags_Clear);

		if (IsNull((*prefArray)->templateStruct))
		{
			if (IsntNull((*prefArray)->elements))
				PGPFreeData((*prefArray)->elements);

			PGPFreeData(*prefArray);
			*prefArray = NULL;
			return kPGPError_OutOfMemory;
		}

		err = sCopyStructDataToPref(prefRef, TRUE, templateStruct,
				(*prefArray)->templateStruct);

		if (IsPGPError(err))
		{
			if (IsntNull((*prefArray)->elements))
				PGPFreeData((*prefArray)->elements);

			PGPFreeData((*prefArray)->templateStruct);
			PGPFreeData(*prefArray);
			*prefArray = NULL;
			return err;
		}
	}

	return kPGPError_NoErr;
}


PGPError PGPFreePrefArray(PGPPrefArray *prefArray)
{
	PGPUInt32 index;
	PGPPrefStruct *prefStruct;

	PGPValidatePtr(prefArray);
	
	pgpAssertMsg(!(prefArray->dirty), "Pref array data or flags were"
		" changed, but changes were not saved with PGPSetPrefArray");

	switch (prefArray->type)
	{
	case kPGPPrefType_String:
	case kPGPPrefType_Byte:
		for (index=0; index<prefArray->numElements; index++)
		{
			if (IsntNull(prefArray->elements[index].data))
				PGPFreeData(prefArray->elements[index].data);
		}
		break;
		
	case kPGPPrefType_Struct:
		PGPFreePrefStruct(prefArray->templateStruct);

		for (index=0; index<prefArray->numElements; index++)
		{
			prefStruct = (PGPPrefStruct *) prefArray->elements[index].data;
			PGPFreePrefStruct(prefStruct);
		}
		break;

	default:
		break;
	}
	
	if (IsntNull(prefArray->elements))
		PGPFreeData(prefArray->elements);

	PGPFreeData(prefArray);

	return kPGPError_NoErr;
}


static PGPError sExportPrefData(PGPIORef memIO, PGPPrefType type,
									PGPSize dataLength, PGPPrefDataUnion data)
{
	PGPSize bytes;
	PGPUInt32 index;
	PGPPrefDataUnion strctData;
	PGPError err = kPGPError_NoErr;

	switch (type)
	{
	case kPGPPrefType_Boolean:
		err = sIOWrite(memIO, sizeof(PGPBoolean), FALSE, &(data.b));
		break;
		
	case kPGPPrefType_Number:
		err = sIOWrite(memIO, sizeof(PGPUInt32), TRUE, &(data.i));
		break;
		
	case kPGPPrefType_String:
		if (IsntNull(data.str))
		{
			bytes = strlen(data.str) + 1;
			
			err = sIOWrite(memIO, sizeof(PGPSize), TRUE, &bytes);
			
			if (IsntPGPError(err))
				err = sIOWrite(memIO, bytes, FALSE, data.str);
		}
		else
		{
			bytes = 0;
			err = sIOWrite(memIO, sizeof(PGPSize), TRUE, &bytes);
		}
		break;
		
	case kPGPPrefType_Byte:
		if (IsntNull(data.p))
		{
			err = sIOWrite(memIO, sizeof(PGPSize), TRUE, &dataLength);
			
			if (IsntPGPError(err) && dataLength)
				err = sIOWrite(memIO, dataLength, FALSE, data.p);
		}
		else
		{
			bytes = 0;
			err = sIOWrite(memIO, sizeof(PGPSize), TRUE, &bytes);
		}
		break;

	case kPGPPrefType_Struct:
		err = sIOWrite(memIO, sizeof(PGPByte), FALSE, 
				&(data.strct->numMembers));

		if (IsPGPError(err))
			break;

		for (index=0; index<data.strct->numMembers; index++)
		{
			err = sIOWrite(memIO, sizeof(PGPUInt32), TRUE, 
					&(data.strct->members[index].type));

			if (IsPGPError(err))
				break;
			
			switch (data.strct->members[index].type)
			{
			case kPGPPrefType_Boolean:
				strctData.b = (PGPBoolean)(size_t) data.strct->members[index].data;
				break;
				
			case kPGPPrefType_Number:
				strctData.i = (PGPUInt32) data.strct->members[index].data;
				break;
				
			case kPGPPrefType_String:
				strctData.str = (char *) data.strct->members[index].data;
				break;
				
			case kPGPPrefType_Byte:
				strctData.p = (PGPByte *) data.strct->members[index].data;
				break;

			default:
				break;
			}

			err = sExportPrefData(memIO, data.strct->members[index].type,
					data.strct->members[index].size, strctData);
		}
		break;

	default:
		break;
	}

	return err;
}


PGPError PGPExportPrefsToBuffer(PGPPrefRef prefRef, 
									PGPSize *bufferSize,
									void **buffer)
{
	PGPIORef			memIO = NULL;
	PGPFileOffset		fileOffset;
	PGPPrefData *		currentPrefData;
	PGPPrefDataUnion	data;
	void *				arrayData;
	PGPSize				bytesRead;
	PGPUInt32			index;
	PGPError			err = kPGPError_NoErr;
	
	if (IsntNull(bufferSize))
		*bufferSize = 0;
	if (IsntNull(buffer))
		*buffer = NULL;

	PGPValidatePref(prefRef);
	PGPValidatePtr(bufferSize);
	PGPValidatePtr(buffer);

	err = PGPNewMemoryIO(prefRef->memoryMgr, (PGPMemoryIORef *) &memIO);
	
	if (IsntPGPError(err))
	{
		currentPrefData = prefRef->prefList;
		
		while (IsntNull(currentPrefData))
		{
			if (currentPrefData->prefIndex == -1)
			{
				sGetNextPrefData(currentPrefData, &currentPrefData);
				continue;
			}

			err = sIOWrite(memIO, sizeof(PGPUInt32), TRUE,
					&(currentPrefData->prefIndex));

			if (IsPGPError(err))
				break;

			err = sIOWrite(memIO, sizeof(PGPUInt32), TRUE,
					&(currentPrefData->prefType));

			if (IsPGPError(err))
				break;

			err = sIOWrite(memIO, sizeof(PGPUInt32), TRUE,
					&(currentPrefData->flags));

			if (IsPGPError(err))
				break;

			switch (currentPrefData->prefType)
			{
			case kPGPPrefType_Array:
				err = sIOWrite(memIO, sizeof(PGPUInt32), TRUE,
						&(currentPrefData->data.a->numElements));

				if (IsPGPError(err))
					break;

				err = sIOWrite(memIO, sizeof(PGPUInt32), TRUE,
						&(currentPrefData->data.a->type));

				if (IsPGPError(err))
					break;

				if (currentPrefData->data.a->type == kPGPPrefType_Struct)
				{
					data.strct = currentPrefData->data.a->templateStruct;
					PGPValidatePtr(data.strct);

					err = sExportPrefData(memIO, kPGPPrefType_Struct,
							sizeof(PGPPrefStruct), data);

					if (IsPGPError(err))
						break;
				}

				for (index=0; index<currentPrefData->data.a->numElements;
				index++)
				{
					arrayData = currentPrefData->data.a->elements[index].data;
					switch (currentPrefData->data.a->type)
					{
					case kPGPPrefType_Boolean:
						data.b = (PGPBoolean)(size_t) arrayData;
						break;
					
					case kPGPPrefType_Number:
						data.i = (PGPUInt32) arrayData;
						break;
					
					case kPGPPrefType_String:
						data.str = (char *) arrayData;
						break;
					
					case kPGPPrefType_Byte:
						data.p = (PGPByte *) arrayData;
						break;