//####################################################################
// S2L5.cpp - (Section 2, Lesson 5) SENDING AN ARRAY OF INTEGERS USING
//                                  SAFEARRAYS
//            This is the RTDX Host Client for Section 2, Lesson 5
//
// This example sends integer values 1-10 to the target
//####################################################################

#import "..\..\..\..\..\cc\bin\rtdxint.dll"
#include <iostream.h>


#define MAX_ELEMENTS 10;

using namespace RTDXINTLib;

int main()
{
        IRtdxExpPtr rtdx;               // holds pointer to IRtdxExp interface
        long status;                    // holds status of RTDX COM API calls
        HRESULT hr;                     // holds status of generic COM API calls
        VARIANT sa;                     // holds a pointer to a SAFEARRAY
        SAFEARRAYBOUND rgsabound[1];    // set the dimension of the SAFEARRAY
        long bufferstate;               // holds the state of the host's write buffer
        short data;                     // holds the element data of SAFEARRAY

        // initialize COM
        ::CoInitialize( NULL );

        // initialize VARIANT
        ::VariantInit( &sa );

        // instantiate the RTDX COM Object
        hr = rtdx.CreateInstance( __uuidof(RTDXINTLib::RtdxExp) );

        cout.setf(ios::showbase);

        if ( FAILED(hr) ) {
                cerr << hex << hr << " - Error: Instantiation failed! \n";
                return -1;
        }

        // open a channel (ichan) for writing
        status = rtdx->Open( "ichan", "W" );

        if ( status != Success ) {
                cerr << hex << status \
                     << " -  Error: Opening of channel \"ichan\" failed! \n";
                return -1;
        }

        // set the VARIANT to be a SAFEARRAY of 16-bit integers
        sa.vt = VT_ARRAY | VT_I2;

        // set the lower bound of the SAFEARRAY
        rgsabound[0].lLbound = 0;

        // set the number of elements in the SAFEARRAY
        rgsabound[0].cElements = MAX_ELEMENTS;

        // create the SAFEARRAY
        sa.parray = SafeArrayCreate( VT_I2, 1, rgsabound );

        // fill up the SAFEARRAY with values
        data = 1;
        for (long i = 0; i < (signed)sa.parray->rgsabound[0].cElements; i++) {
                hr = ::SafeArrayPutElement( sa.parray, &i, (short*)&data);
                data++;
        }

        // send data to the target
        status = rtdx->Write(sa, &bufferstate);

        if (status != Success) {
                cerr << hex << status << " - Error: Write failed!\n";
                return -1;
        }

        // print out data
        for (long j=0; j<(signed)sa.parray->rgsabound[0].cElements; j++) {
                hr = ::SafeArrayGetElement( sa.parray, &j, (short*)&data);
                cout << "Value " << data << " was sent to the target!\n";
        }

        // close the channel
        status = rtdx->Close();

        // release the RTDX COM Object
        rtdx.Release();

        // clear VARIANT
        ::VariantClear(&sa);

        // unitialize COM
        ::CoUninitialize();

        return 0;
}