新增了PQDIF补招线程，导入了新的lib库
This commit is contained in:
522
LFtid1056/pqdif/include/pqdsupport.cpp
Normal file
522
LFtid1056/pqdif/include/pqdsupport.cpp
Normal file
@@ -0,0 +1,522 @@
|
||||
/*
|
||||
** CPQDIF_COMSupport class. Implements support member functions so that
|
||||
** make dealing with COM/OLE/ActiveX much easier.
|
||||
** --------------------------------------------------------------------------
|
||||
** This class is a Singleton class; this means that only one instance of it
|
||||
** should ever be created. This instance is made global, and is one of the
|
||||
** only global objects in the entire system.
|
||||
** --------------------------------------------------------------------------
|
||||
**
|
||||
** File name: $Workfile: pqdsupport.cpp $
|
||||
** Last modified: $Modtime: 4/15/02 3:19p $
|
||||
** Last modified by: $Author: Wadef $
|
||||
**
|
||||
** VCS archive path: $Archive: /PQDIF/PQDcom/PQDcom4/pqdiflib/pqdsupport.cpp $
|
||||
** VCS revision: $Revision: 5 $
|
||||
*/
|
||||
|
||||
#ifdef PQDIF_USE_COM
|
||||
|
||||
#include "PQDIF_classes.h"
|
||||
#include "pqdsupport.h"
|
||||
|
||||
const GUID ID_NULL = { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } };
|
||||
|
||||
// The one and only support object (Singleton)
|
||||
CPQDIF_COMSupport theSupport;
|
||||
|
||||
|
||||
|
||||
// Construction
|
||||
// ============
|
||||
|
||||
CPQDIF_COMSupport::CPQDIF_COMSupport()
|
||||
{
|
||||
}
|
||||
|
||||
CPQDIF_COMSupport::~CPQDIF_COMSupport()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::NewVariantArrayFromGUID
|
||||
(
|
||||
VARIANT& var,
|
||||
const GUID& guid
|
||||
)
|
||||
{
|
||||
bool status = false;
|
||||
const int countLongs = 4;
|
||||
BYTE * pbData;
|
||||
|
||||
// Set the variant to a 1-byte array
|
||||
VariantInit( &var );
|
||||
var.vt = VT_ARRAY + VT_I4;
|
||||
var.parray = SafeArrayCreateVector( VT_I4, 0, countLongs );
|
||||
|
||||
// If a safe array of doubles was passed then ...
|
||||
if( var.parray != NULL)
|
||||
{
|
||||
if( !FAILED( SafeArrayAccessData( var.parray, (void **) &pbData ) ) )
|
||||
{
|
||||
// Copy the contents of the GUID
|
||||
memcpy( pbData, &guid, countLongs * sizeof( long ) );
|
||||
SafeArrayUnaccessData( var.parray );
|
||||
status = true;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::SetGUIDFromVariantArray
|
||||
(
|
||||
GUID& guid,
|
||||
const VARIANT& var
|
||||
) const
|
||||
{
|
||||
bool status = false;
|
||||
long lLower;
|
||||
long lUpper;
|
||||
long countItems;
|
||||
BYTE * pbData;
|
||||
|
||||
guid = ID_NULL;
|
||||
|
||||
// Valid array of long [ 4 ]?
|
||||
if( ( var.vt & VT_ARRAY ) /* && ( var.vt & VT_I4 )*/ && var.parray )
|
||||
{
|
||||
// Validate the size of the array
|
||||
SafeArrayGetUBound( var.parray, 1, &lUpper );
|
||||
SafeArrayGetLBound( var.parray, 1, &lLower );
|
||||
countItems = (lUpper - lLower + 1);
|
||||
|
||||
if( countItems == 4 )
|
||||
{
|
||||
VARIANT HUGEP *pvLongs;
|
||||
|
||||
if (!FAILED(SafeArrayAccessData(var.parray, reinterpret_cast<void HUGEP**>(&pvLongs))))
|
||||
{
|
||||
if (var.vt & VT_VARIANT)
|
||||
{
|
||||
INT4 * pInt = (INT4 *)&guid;
|
||||
|
||||
for (int count = 0; count < 4; count++, pInt++)
|
||||
*pInt = pvLongs[count].lVal;
|
||||
}
|
||||
else
|
||||
{
|
||||
pbData = (BYTE *)pvLongs;
|
||||
// Copy the GUID
|
||||
memcpy( &guid, pbData, sizeof( guid ) );
|
||||
status = true;
|
||||
}
|
||||
|
||||
SafeArrayUnaccessData( var.parray );
|
||||
}
|
||||
} // Got safe array data
|
||||
} // Valid safe array
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::NewVariantArrayFromVector
|
||||
(
|
||||
VARIANT& var,
|
||||
CPQDIF_E_Vector& vect
|
||||
)
|
||||
{
|
||||
bool status = false;
|
||||
VARTYPE vtSingle;
|
||||
long typePhysical;
|
||||
long sizePhysical;
|
||||
long countItems;
|
||||
BYTE * pbData;
|
||||
INT1 * pdataSource;
|
||||
|
||||
// Check the physical type for the size we need...
|
||||
// (and how many items are in the array)
|
||||
typePhysical = vect.GetPhysicalType();
|
||||
sizePhysical = theInfo.GetNumBytesOfType( typePhysical );
|
||||
vect.GetCount( countItems );
|
||||
|
||||
_variant_t varV;
|
||||
// Grab the first item to see what variant type the array should be...
|
||||
status = vect.GetValue( 0, varV );
|
||||
if( status )
|
||||
{
|
||||
// Got the variant type
|
||||
vtSingle = varV.vt;
|
||||
status = false;
|
||||
|
||||
// Set the variant to an array of this type
|
||||
VariantInit( &var );
|
||||
|
||||
var.vt = VT_ARRAY | vtSingle;
|
||||
var.parray = SafeArrayCreateVector( vtSingle, 0, countItems );
|
||||
|
||||
// If a safe array of doubles was passed then ...
|
||||
if( var.parray != NULL)
|
||||
{
|
||||
if( !FAILED( SafeArrayAccessData( var.parray, (void **) &pbData ) ) )
|
||||
{
|
||||
pdataSource = reinterpret_cast<INT1 *>(vect.GetRawData());
|
||||
if( pdataSource )
|
||||
{
|
||||
// Copy the entire block of data across by physical item size
|
||||
memcpy( pbData, pdataSource, countItems * sizePhysical );
|
||||
status = true;
|
||||
}
|
||||
|
||||
SafeArrayUnaccessData( var.parray );
|
||||
} // Got safe array data
|
||||
} // Valid safe array
|
||||
} // Valid data type
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::NewVariantArrayFromDouble
|
||||
(
|
||||
VARIANT& var,
|
||||
double * arValues,
|
||||
long countItems
|
||||
)
|
||||
{
|
||||
bool status = false;
|
||||
VARTYPE vtSingle;
|
||||
long sizePhysical;
|
||||
BYTE * pbData;
|
||||
|
||||
// Set the variant to an array of this type
|
||||
sizePhysical = sizeof( double );
|
||||
vtSingle = VT_R8;
|
||||
VariantInit( &var );
|
||||
var.vt = VT_ARRAY | vtSingle;
|
||||
var.parray = SafeArrayCreateVector( vtSingle, 0, countItems );
|
||||
|
||||
// If a safe array of doubles was passed then ...
|
||||
if( var.parray != NULL)
|
||||
{
|
||||
if( !FAILED( SafeArrayAccessData( var.parray, (void **) &pbData ) ) )
|
||||
{
|
||||
if( arValues )
|
||||
{
|
||||
// Copy the entire block across
|
||||
memcpy( pbData, (BYTE *) arValues, sizePhysical * countItems );
|
||||
status = true;
|
||||
}
|
||||
|
||||
SafeArrayUnaccessData( var.parray );
|
||||
} // Got safe array data
|
||||
} // Valid safe array
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
long GetPhysicalTypeFromVariant( const VARIANT& var, long typeElement )
|
||||
{
|
||||
long typePhysical = 0;
|
||||
BOOL isArray = FALSE;
|
||||
int countDims = 0;
|
||||
long lUpper;
|
||||
long lLower;
|
||||
long countItemsLastDim = 0;
|
||||
|
||||
SAFEARRAY * psa = NULL;
|
||||
|
||||
// Is this an array?
|
||||
if( var.vt & VT_ARRAY )
|
||||
{
|
||||
// Which safearray?
|
||||
if( var.vt & VT_BYREF )
|
||||
{
|
||||
if( var.pparray )
|
||||
psa = *var.pparray;
|
||||
}
|
||||
else
|
||||
{
|
||||
psa = var.parray;
|
||||
}
|
||||
|
||||
if( psa )
|
||||
{
|
||||
isArray = TRUE;
|
||||
countDims = SafeArrayGetDim( psa );
|
||||
|
||||
// Count the number of items in the last dimension...
|
||||
SafeArrayGetUBound( var.parray, countDims, &lUpper );
|
||||
SafeArrayGetLBound( var.parray, countDims, &lLower );
|
||||
countItemsLastDim = (lUpper - lLower + 1);
|
||||
}
|
||||
}
|
||||
|
||||
// Is this a vector? If so, we only consider it an "array" if there
|
||||
// are two dimensions.
|
||||
if( typeElement == ID_ELEMENT_TYPE_VECTOR && isArray )
|
||||
{
|
||||
if( countDims < 2 )
|
||||
{
|
||||
isArray = FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
switch( var.vt & VT_TYPEMASK )
|
||||
{
|
||||
case VT_BOOL:
|
||||
typePhysical = ID_PHYS_TYPE_BOOLEAN2 ;
|
||||
break;
|
||||
|
||||
case VT_I1:
|
||||
typePhysical = ID_PHYS_TYPE_INTEGER1 ;
|
||||
break;
|
||||
|
||||
case VT_I2:
|
||||
typePhysical = ID_PHYS_TYPE_INTEGER2 ;
|
||||
break;
|
||||
|
||||
case VT_I4:
|
||||
typePhysical = ID_PHYS_TYPE_INTEGER4 ;
|
||||
if( isArray && countItemsLastDim == 4 )
|
||||
{
|
||||
typePhysical = ID_PHYS_TYPE_GUID;
|
||||
}
|
||||
break;
|
||||
|
||||
// Real/complex
|
||||
case VT_R4:
|
||||
typePhysical = ID_PHYS_TYPE_REAL4 ;
|
||||
if( isArray && countItemsLastDim == 2 )
|
||||
{
|
||||
typePhysical = ID_PHYS_TYPE_COMPLEX8;
|
||||
}
|
||||
break;
|
||||
|
||||
case VT_R8:
|
||||
typePhysical = ID_PHYS_TYPE_REAL8;
|
||||
if( isArray && countItemsLastDim == 2 )
|
||||
{
|
||||
typePhysical = ID_PHYS_TYPE_COMPLEX16;
|
||||
}
|
||||
break;
|
||||
|
||||
// Date/time
|
||||
case VT_DATE:
|
||||
typePhysical = ID_PHYS_TYPE_TIMESTAMPPQDIF ;
|
||||
break;
|
||||
}
|
||||
|
||||
return typePhysical;
|
||||
}
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::SetVectorArrayFromVariant( CPQDIF_E_Vector& vect, VARIANT& values )
|
||||
{
|
||||
bool status = false;
|
||||
long typePhysical;
|
||||
unsigned int sizeSingle;
|
||||
long sizeType;
|
||||
BYTE * pbData;
|
||||
INT1 * pdataTarget;
|
||||
|
||||
SAFEARRAY * psa = NULL;
|
||||
|
||||
long lLower;
|
||||
long lUpper;
|
||||
long countItems;
|
||||
long countDimensions;
|
||||
long countItemsDim2 = 0;
|
||||
|
||||
// Make sure it is an array
|
||||
if( values.vt & VT_ARRAY )
|
||||
{
|
||||
// Is valid physical type set?
|
||||
//typePhysical = vect.GetPhysicalType();
|
||||
typePhysical = 0;
|
||||
if( typePhysical == 0 )
|
||||
{
|
||||
typePhysical = GetPhysicalTypeFromVariant(
|
||||
values, vect.GetElementType() );
|
||||
|
||||
vect.SetPhysicalType( typePhysical );
|
||||
sizeType = theInfo.GetNumBytesOfType( typePhysical );
|
||||
}
|
||||
|
||||
// Which safearray?
|
||||
if( values.vt & VT_BYREF )
|
||||
{
|
||||
if( values.pparray )
|
||||
psa = *values.pparray;
|
||||
}
|
||||
else
|
||||
{
|
||||
psa = values.parray;
|
||||
}
|
||||
|
||||
if( !FAILED( SafeArrayAccessData( psa, (void **)&pbData ) ) )
|
||||
{
|
||||
// Get the physical size of each element
|
||||
sizeSingle = SafeArrayGetElemsize( values.parray );
|
||||
|
||||
// Get the size of the new array.
|
||||
SafeArrayGetUBound( values.parray, 1, &lUpper );
|
||||
SafeArrayGetLBound( values.parray, 1, &lLower );
|
||||
countItems = (lUpper - lLower + 1);
|
||||
|
||||
// Is there a second dimension?
|
||||
countDimensions = SafeArrayGetDim( values.parray );
|
||||
if( countDimensions > 1 )
|
||||
{
|
||||
SafeArrayGetUBound( values.parray, 2, &lUpper );
|
||||
SafeArrayGetLBound( values.parray, 2, &lLower );
|
||||
countItemsDim2 = (lUpper - lLower + 1);
|
||||
}
|
||||
|
||||
// Configure vector
|
||||
vect.SetCount( countItems );
|
||||
|
||||
pdataTarget = reinterpret_cast<INT1 *>(vect.GetRawData());
|
||||
|
||||
if( pdataTarget && (int) sizeType == (int) sizeSingle )
|
||||
{
|
||||
// Copy the caller's data into the array.
|
||||
memcpy( pdataTarget, pbData, countItems * sizeSingle );
|
||||
status = true;
|
||||
}
|
||||
|
||||
SafeArrayUnaccessData( psa );
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::NewArrayUINT4FromVariant
|
||||
(
|
||||
UINT4 ** aidxChannelTriggerLocal,
|
||||
long& countItems,
|
||||
VARIANT& var
|
||||
)
|
||||
{
|
||||
bool status = false;
|
||||
long lLower;
|
||||
long lUpper;
|
||||
BYTE * pbData;
|
||||
long * pSource;
|
||||
UINT4 * pTarget;
|
||||
|
||||
// Init
|
||||
*aidxChannelTriggerLocal = NULL;
|
||||
countItems = 0;
|
||||
|
||||
// Valid array of long?
|
||||
if( ( var.vt & VT_ARRAY ) && ( var.vt & VT_I4 ) && var.parray )
|
||||
{
|
||||
// Validate the size of the array
|
||||
SafeArrayGetUBound( var.parray, 1, &lUpper );
|
||||
SafeArrayGetLBound( var.parray, 1, &lLower );
|
||||
countItems = (lUpper - lLower + 1);
|
||||
|
||||
if( countItems > 0 )
|
||||
{
|
||||
if( !FAILED( SafeArrayAccessData( var.parray, (void **) &pbData ) ) )
|
||||
{
|
||||
// Allocate space
|
||||
*aidxChannelTriggerLocal = new UINT4[ countItems ];
|
||||
|
||||
// Create temp pointers (to be incremented) and copy
|
||||
pSource = (long *) pbData;
|
||||
pTarget = *aidxChannelTriggerLocal;
|
||||
for( long idx = 0; idx < countItems; idx++, pSource++, pTarget++ )
|
||||
{
|
||||
*pTarget = (UINT4) *pSource;
|
||||
}
|
||||
|
||||
status = true;
|
||||
SafeArrayUnaccessData( var.parray );
|
||||
}
|
||||
} // Got safe array data
|
||||
} // Valid safe array
|
||||
|
||||
return status;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::NewComStringFromVector( CPQDIF_E_Vector& vect, BSTR * str )
|
||||
{
|
||||
bool status = false;
|
||||
long countItems;
|
||||
string strOutput;
|
||||
INT1 * pdataSource;
|
||||
|
||||
// Init
|
||||
strOutput = "";
|
||||
vect.GetCount( countItems );
|
||||
|
||||
switch( vect.GetPhysicalType() )
|
||||
{
|
||||
case ID_PHYS_TYPE_CHAR1:
|
||||
pdataSource = reinterpret_cast<INT1 *>(vect.GetRawData());
|
||||
if( pdataSource )
|
||||
{
|
||||
// Convert it to a string
|
||||
USES_CONVERSION;
|
||||
strOutput = (const char *) pdataSource;
|
||||
*str = SysAllocString(_bstr_t(strOutput.c_str()));
|
||||
status = true;
|
||||
}
|
||||
break;
|
||||
|
||||
case ID_PHYS_TYPE_CHAR2:
|
||||
// NOT SUPPORTED
|
||||
break;
|
||||
|
||||
default:
|
||||
status = true;
|
||||
break;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::SetVectorArrayFromString( CPQDIF_E_Vector& vect, BSTR * str )
|
||||
{
|
||||
bool status = false;
|
||||
|
||||
USES_CONVERSION;
|
||||
|
||||
// Init
|
||||
vect.SetValues( W2A(*str) );
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::SetDateFromTimeStamp( DATE& date, const TIMESTAMPPQDIF& ts )
|
||||
{
|
||||
date = (double) ts.day
|
||||
+ ( (double) ts.sec / (double) SECONDS_PER_DAY );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool CPQDIF_COMSupport::SetTimeStampFromDate( TIMESTAMPPQDIF& ts, const DATE& date )
|
||||
{
|
||||
// Take integral portion for the day
|
||||
ts.day = (UINT4) date;
|
||||
|
||||
// Take the fractional portion for the seconds
|
||||
ts.sec = ( (REAL8) SECONDS_PER_DAY ) * ( (REAL8) date - (REAL8) ts.day );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif // PQDIF_USE_COM
|
||||
Reference in New Issue
Block a user