What is the VARIANT's value type of enumeration

What is the VARIANT's value type of enumeration

Postby bcbooo » 08 March 2013, 02:49

In the interface of ICapeThermoMaterial, I need to use SetPresentPhases & GetPresentPhases, they all have the parameter "phaseStatus", it is a CapeArrayEnumeration type, like the following:

enum eCapePhaseStatus
{
CAPE_UNKNOWNPHASESTATUS = 0,
CAPE_ATEQUILIBRIUM = 1,
CAPE_ESTIMATES = 2
};

My building environment is Visual C++ 2005, so my code like this:

VARIANT phaseLabels,phaseStatus;
phaseLabels.vt=VT_EMPTY;
phaseStatus.vt=VT_EMPTY;
pThermoMaterial->GetPresentPhases(&phaseLabels,&phaseStatus); // the pThermoMaterial is a smart pointer to the ICapeThermoMaterial ,has been initialized.

Then the PME will return the phaseLabels and phaseStaus, I know the phaseLabels' type is VT_BSTR, but what is phaseStatus' ? VT_I4 , VT_INT or VT_R8 ?
bcbooo
 
Posts: 66
Joined: 22 November 2012, 06:41
Location: China

Re: What is the VARIANT's value type of enumeration

Postby jasper » 08 March 2013, 08:00

This information is sadly lacking from the standard specifications.

If you pass an enumeration object to others, I would use VT_I4. If you interpret enumeration objects passed to you from others, I would be ready to interpret the most common integer types: VT_I2, VT_I4, VT_UI2, VT_UI4, VT_INT, VT_UINT. The real type VT_R8 does not make too much sense in this context.

I have yet to see any other interpretation than VT_I4 as this corresponds to CapeInteger.

Similar confusion exists over the data type of dimensionality of the parameters. This has now been settled upon and should be VT_R8. However, when interpreting data from other sources, I would be ready to deal with other numeric types, especially VT_I4.
User avatar
jasper
 
Posts: 1128
Joined: 24 October 2012, 15:33
Location: Spain

Re: What is the VARIANT's value type of enumeration

Postby colancto » 15 March 2013, 16:16

Would that call for an item in an Errata and Clarifications document, starting with the Errata and Clarifications document for Thermo 1.1 even if this issue appears within other CAPE-OPEN specifications?
User avatar
colancto
Administrateur
 
Posts: 92
Joined: 23 October 2012, 11:46

Re: What is the VARIANT's value type of enumeration

Postby jasper » 15 March 2013, 16:24

Yes - actually this belongs to the M&T Sig.
User avatar
jasper
 
Posts: 1128
Joined: 24 October 2012, 15:33
Location: Spain

Re: What is the VARIANT's value type of enumeration

Postby wbarrett » 25 March 2013, 17:20

I am not sure that an Errata and Clarifications document is needed in this case. This is more of a a "How to" question, and it would seem that the forum is an appropriate location for that.

First off, in C++, enums are integer data types. The SAFEARRAY can be an integer array, and the VARIANT of type VT_ARRAY | VT_I4. I have created some C++ code in VS2008. I am including the main program and two functions: one returns a SAFEARRAY by reference and the other returns a VARIANT wrapping the SAFEARRAY. The code I have to create the SAFEARRAY, and wrap it waith a VARIANT looks like this...

Code: Select all
//This code defines the CapePhaseStatus enumeration.
typedef enum CapePhaseStatus{
   CAPE_UNKNOWNPHASESTATUS = 0,
   CAPE_ATEQUILIBRIUM = 1,
   CAPE_ESTIMATES = 2
} PhaseStatus;


Code: Select all
// This class creates the SAFEARRAY and VARIANT

class TestSafeArray
{
public:
   TestSafeArray(void){};
   ~TestSafeArray(void);

   HRESULT CreateSafeArray(SAFEARRAY** phaseStatus)
   {
      // Create an array of Phases Statuses
      CapePhaseStatus statuses[6];
      statuses[0] = CAPE_ATEQUILIBRIUM;
      statuses[1] = CAPE_ESTIMATES;
      statuses[2] = CAPE_UNKNOWNPHASESTATUS;
      statuses[3] = CAPE_ATEQUILIBRIUM;
      statuses[4] = CAPE_ESTIMATES;
      statuses[5] = CAPE_UNKNOWNPHASESTATUS;

      // Create D array of long integers.
      SAFEARRAYBOUND sabdBounds[1] = { sizeof(statuses)/sizeof(CapePhaseStatus), 0};
      SAFEARRAY* retVal  = SafeArrayCreate(VT_I4, 1, sabdBounds);
      retVal->cLocks++;

      // Fill array with values
      retVal->pvData = &statuses;
      *phaseStatus = retVal;
      return S_OK;
   }

   HRESULT CreateVariantArray(VARIANT** phaseStatus)
   {
      VARIANT *retVal = new VARIANT();
      VariantInit(retVal);
      retVal->vt = VT_ARRAY | VT_I4;
      this->CreateSafeArray(&retVal->parray);
      *phaseStatus = retVal;
      return S_OK;
   }
};



The calling code looks like this...

Code: Select all
int _tmain(int argc, _TCHAR* argv[])
{

   // Create an instance of the class that makes the enum arrays...
   TestSafeArray* tester = new TestSafeArray();

   // Try as SafeArray...
   SAFEARRAY *pSafeArray;
   tester->CreateSafeArray(&pSafeArray);

   // Get an array of ints from the SafeArray
   SAFEARRAYBOUND arrayBounds = pSafeArray->rgsabound[0];
   int lowerBound = (int)arrayBounds.lLbound;
   int elements = (int)arrayBounds.cElements;
   int *intValues = (int*)pSafeArray->pvData;
   // convert the ints to CapePhaseStatuses
   CapePhaseStatus retrievedStatuses[10];

   for (int i = lowerBound; i < lowerBound+elements; i++)
   {
      int temp = intValues[i];
      retrievedStatuses[i] = (CapePhaseStatus)temp;
   }
   pSafeArray->cLocks--;

   // Now do as a VARIANT...
   VARIANT *pVariant;
   tester->CreateVariantArray(&pVariant);

   // Get an array of ints from the SafeArray
   arrayBounds = pVariant->parray->rgsabound[0];
   lowerBound = (int)arrayBounds.lLbound;
   elements = (int)arrayBounds.cElements;
   intValues = (int*)pVariant->parray->pvData;
   CapePhaseStatus retrievedStatuses2[10];

   for (int i = lowerBound; i < lowerBound+elements; i++)
   {
      int temp = intValues[i];
      retrievedStatuses2[i] = (CapePhaseStatus)temp;
   }
   pVariant->parray->cLocks--;
   return 0;
}


When I run this, both retrievedStatuses and retrievedStatuses2 contain an array of CapePhaseStatus enum data.
wbarrett
 
Posts: 4
Joined: 16 March 2013, 01:21

Re: What is the VARIANT's value type of enumeration

Postby jasper » 26 March 2013, 07:31

First off, in C++, enums are integer data types.


It would help to state that enumeration types are to be treated as CapeInteger then. Which makes sense, but it is not clear as CAPE-OPEN is not built upon C++ assumptions.

I do agree that this is the most sensible data type and all implementations seem to be using that as it is.
User avatar
jasper
 
Posts: 1128
Joined: 24 October 2012, 15:33
Location: Spain


Return to Thermodynamic components

Who is online

Users browsing this forum: No registered users and 1 guest

cron