//####################################################################

// 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

        long 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 32-bit integers

        sa.vt = VT_ARRAY | VT_I4;



        // 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_I4, 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, (long*)&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, (long*)&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;

}