pqdcom4.cpp

一个PQDIF的测试用例

// Machine generated IDispatch wrapper class(es) created with ClassWizard

#include "stdafx.h"
#include "pqdcom4.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif



/////////////////////////////////////////////////////////////////////////////
// IPQDIFPhysical properties

/////////////////////////////////////////////////////////////////////////////
// IPQDIFPhysical operations

CString IPQDIFPhysical::GetFlatFileName()
{
	CString result;
	InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void IPQDIFPhysical::SetFlatFileName(LPCTSTR lpszNewValue)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 lpszNewValue);
}

long IPQDIFPhysical::GetCompressionAlgorithm()
{
	long result;
	InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void IPQDIFPhysical::SetCompressionAlgorithm(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long IPQDIFPhysical::GetCompressionStyle()
{
	long result;
	InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void IPQDIFPhysical::SetCompressionStyle(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long IPQDIFPhysical::GetCanWriteIncremental()
{
	long result;
	InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void IPQDIFPhysical::SetCanWriteIncremental(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long IPQDIFPhysical::GetTagCount()
{
	long result;
	InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void IPQDIFPhysical::SetTagCount(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

long IPQDIFPhysical::Read()
{
	long result;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IPQDIFPhysical::Close()
{
	long result;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IPQDIFPhysical::RecordGetCount()
{
	long result;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IPQDIFPhysical::RecordGetInfo(long index, VARIANT* tagRecordType, BSTR* nameRecordType, long* sizeHeader, long* sizeRecord, long* posThisRecord, long* posNextRecord)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PVARIANT VTS_PBSTR VTS_PI4 VTS_PI4 VTS_PI4 VTS_PI4;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index, tagRecordType, nameRecordType, sizeHeader, sizeRecord, posThisRecord, posNextRecord);
	return result;
}

long IPQDIFPhysical::RecordGetCollection(long index, long* pElement)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PI4;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index, pElement);
	return result;
}

long IPQDIFPhysical::ElementGetTag(long pElement, VARIANT* tagElement, BSTR* nameTagElement)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PVARIANT VTS_PBSTR;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pElement, tagElement, nameTagElement);
	return result;
}

long IPQDIFPhysical::ElementGetType(long pElement, long* typeElement, long* typePhysical)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PI4 VTS_PI4;
	InvokeHelper(0xc, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pElement, typeElement, typePhysical);
	return result;
}

long IPQDIFPhysical::ElementGetScalarData(long pElement, VARIANT* data)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PVARIANT;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pElement, data);
	return result;
}

long IPQDIFPhysical::ElementGetVectorData(long pElement, long index, VARIANT* data)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_PVARIANT;
	InvokeHelper(0xe, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pElement, index, data);
	return result;
}

long IPQDIFPhysical::ElementGetVectorCount(long pElement, long* count)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PI4;
	InvokeHelper(0xf, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pElement, count);
	return result;
}

long IPQDIFPhysical::ElementCreate(long typeElement, long* pElement)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PI4;
	InvokeHelper(0x10, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		typeElement, pElement);
	return result;
}

long IPQDIFPhysical::ElementDestroy(long pElement)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x11, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pElement);
	return result;
}

long IPQDIFPhysical::CollectionGetCount(long pCollection, long* count)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PI4;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pCollection, count);
	return result;
}

long IPQDIFPhysical::CollectionGetEntry(long pCollection, long index, long* pElement)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_PI4;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pCollection, index, pElement);
	return result;
}

long IPQDIFPhysical::CollectionAddEntry(long pCollection, long pElement)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pCollection, pElement);
	return result;
}

long IPQDIFPhysical::CollectionInsertEntry(long pCollection, long indexToInsert, long pElement)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pCollection, indexToInsert, pElement);
	return result;
}

long IPQDIFPhysical::CollectionRemoveEntry(long pCollection, long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pCollection, index);
	return result;
}

long IPQDIFPhysical::CollectionDestroyEntry(long pCollection, long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pCollection, index);
	return result;
}

long IPQDIFPhysical::WriteNew()
{
	long result;
	InvokeHelper(0x18, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IPQDIFPhysical::WriteIncremental()
{
	long result;
	InvokeHelper(0x19, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IPQDIFPhysical::ElementGetVectorArray(long pElement, VARIANT* values)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PVARIANT;
	InvokeHelper(0x1a, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pElement, values);
	return result;
}

long IPQDIFPhysical::ElementIsString(long pElement)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1b, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pElement);
	return result;
}

long IPQDIFPhysical::ElementGetString(long pElement, BSTR* value)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PBSTR;
	InvokeHelper(0x1c, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pElement, value);
	return result;
}

long IPQDIFPhysical::RecordCreateByNameInsert(BSTR* nameTagRecordType, long indexToInsert)
{
	long result;
	static BYTE parms[] =
		VTS_PBSTR VTS_I4;
	InvokeHelper(0x1d, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		nameTagRecordType, indexToInsert);
	return result;
}

long IPQDIFPhysical::RecordDestroy(long index)
{
	long result;
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1e, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		index);
	return result;
}

long IPQDIFPhysical::ScalarSetValue(long pScalar, VARIANT* value)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PVARIANT;
	InvokeHelper(0x1f, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pScalar, value);
	return result;
}

long IPQDIFPhysical::VectorSetString(long pVector, BSTR* value)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PBSTR;
	InvokeHelper(0x20, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pVector, value);
	return result;
}

long IPQDIFPhysical::VectorSetArray(long pVector, VARIANT* values)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_PVARIANT;
	InvokeHelper(0x21, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pVector, values);
	return result;
}

long IPQDIFPhysical::ReadChunk(VARIANT* chunkPQDIF)
{
	long result;
	static BYTE parms[] =
		VTS_PVARIANT;
	InvokeHelper(0x22, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		chunkPQDIF);
	return result;
}

long IPQDIFPhysical::WriteChunk(VARIANT* chunkPQDIF)
{
	long result;
	static BYTE parms[] =
		VTS_PVARIANT;
	InvokeHelper(0x23, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		chunkPQDIF);
	return result;
}

long IPQDIFPhysical::New()
{
	long result;
	InvokeHelper(0x24, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
	return result;
}

long IPQDIFPhysical::ObservationGetSeriesData(long pRecordObserv, long idxChannel, long idxSeries, VARIANT* values)
{
	long result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_PVARIANT;
	InvokeHelper(0x26, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
		pRecordObserv, idxChannel, idxSeries, values);
	return result;
}