// TheCoClass.cpp : Implementation of CTheCoClass
#include "stdafx.h"
#include "BasicATLServer.h"
#include "TheCoClass.h"
#include "BasicClasses//Include//SafeArray.h"
#include <numeric>

/////////////////////////////////////////////////////////////////////////////
// CTheCoClass

//
STDMETHODIMP CTheCoClass::getString(BSTR *theString)
{
	Lock();
	*theString=m_theString.Copy();
	Unlock();
	return S_OK;
}

STDMETHODIMP CTheCoClass::setString(BSTR theString)
{
	Lock();
	m_theString=theString;
	Unlock();
	return S_OK;
}


using namespace std;


STDMETHODIMP CTheCoClass::putRawArray( long size, double array[] )
{
	copy( array, array+size, back_inserter(previousResults) );
	return S_OK;
}

STDMETHODIMP CTheCoClass::getRawArray( long size, double array[] )
{
	if( previousResults.size()<size )
		return S_FALSE;
	copy( previousResults.end()-size, previousResults.end(), array );
	return S_OK;
}


using namespace kaBasicClasses;
using namespace std;

STDMETHODIMP CTheCoClass::sum( VARIANT theArray, double* theSum )
{
	Lock();
	try {
		string s=getSymbolicVT(theArray.vt);
		const char* str=s.c_str();
		CHECK( theArray.vt== (VT_ARRAY | VT_VARIANT), exception )
		SafeArray<Variant> array(theArray);
		*theSum=accumulate(array.begin(),array.end(),0);
		previousResults.push_back(*theSum);
		Unlock();
		return S_OK;
	}
	catch( exception e )
	{
		const char * err=e.what();
	}
	catch( ... )
	{
		
	}
	Unlock();
	return DISP_E_TYPEMISMATCH;	
}



STDMETHODIMP CTheCoClass::getArray( VARIANT* theArray )
{
	Lock();
	try 
	{
		SAFEARRAY* arr=createSafeArrayOfVariants<vector<double>::iterator, double>
				(previousResults.begin(),previousResults.end());
		CHECK( VariantClear(theArray)==S_OK, std::exception )
		theArray->vt=VT_ARRAY | VT_VARIANT;
		theArray->parray=arr;
		Unlock();
		return S_OK;
	}
	catch( ... )
	{

	}
	Unlock();
	return DISP_E_TYPEMISMATCH;
}