__declspec(dllexport) class ThreadManager {
	public:
__declspec(dllexport) static UINT32 setThreadPriority(UINT32 tPriority);
 
__declspec(dllexport) static UINT32 setPriorityClass(UINT32 pClass);
 
__declspec(dllexport) static UINT32 setProcessorMask(UINT32 pAffinity);
 
__declspec(dllexport) static UINT32 changeMATLABSeed(UINT32 inputSeed);
 
					  static BOOL setHandles(HANDLE* thread, HANDLE* process);
 
__declspec(dllexport) static BOOL testFun(UINT32 testInt);
 
					  static UINT initializeProgram(ostream* consoleStream);
};

    class ThreadManagerWrapper
    {
        [DllImport("MATLABCPPThreadLibrary.dll", CharSet = CharSet.Auto)]
        public static extern UInt32 setThreadPriority(UInt32 tPriority);
 
        [DllImport("MATLABCPPThreadLibrary.dll", CharSet = CharSet.Auto)]
        public static extern UInt32 setPriorityClass(UInt32 pClass);
 
        [DllImport("MATLABCPPThreadLibrary.dll", CharSet = CharSet.Auto)]
        public static extern UInt32 setProcessorMask(UInt32 pAffinity);
 
        [DllImport("MATLABCPPThreadLibrary.dll", CharSet = CharSet.Auto)]
        public static extern UInt32 changeMATLABSeed(UInt32 inputSeed);
 
        [DllImport("MATLABCPPThreadLibrary.dll", CharSet = CharSet.Auto)]
        public static extern Boolean testFun(UInt32 testInt);
 
    };

UINT MATLABNamespace::MATLABFunctionThreader::createMATLABThread(LPVOID printString)
{  
  mwArray mxInversions, mxSample, mxTime;
 
  inverterFunction(3, mxInversions, mxSample, mxTime);
 
 return 0;
}

#include "stdafx.h"

#include <vcclr.h>
using namespace System;

String ^ Namespace::NativeToString( const char * charArray ) {
    String ^ returnValue = String::Empty;
 
    while ( *charArray != '\0' ) {
        returnValue += (char)*charArray;
        charArray++;
    }
 
    return returnValue;
}
 
const char * Namespace::StringToNative( String ^ str ) {
    array<Char, 1> ^ charArray = str->ToCharArray();
    size_t size = charArray->Length + 1;
    char * returnValue = (char *)malloc(size * sizeof(char));
 
    for ( int i = 0 ; i < charArray->Length ; i++ ) {
        returnValue[i] = (char)charArray[i];
    }
    // allocated an extra char for null
    returnValue[charArray->Length] = '\0';
 
    return returnValue;
}

 
class MATLABDataWrapper
{
public:
 
//data members... I know these guys should be private, but nobody'll really access em'
 mwArray mxInversions; 
 mwArray mxSample;
 mwArray mxTime;
 
 String^ MATLABNamespace::MATLABDataWrapper::toString(void)
 {
 char buffer[100]; //my data out should never be larger than 100 spaces... I /think/
 
 //annoying hoop to jump through to turn my mwStrings into strings.
  sprintf_s ( buffer, 100, "%s\t%s\t%s", 
          (const char*)this->mxInversions.ToString(),
          (const char*)this->mxSample.ToString(),
          (const char*)this->mxTime.ToString());
 
        //copy the buffer to a new string?  gcnew creates a garbage collected string...
	 String ^outputStr = gcnew String(buffer,0,100);
 
        /return the garbage collected string, but trim the blanks off the end.
	 return outputStr->Trim();
 }
 
};

//must return UINT and can only have one param of type LPVOID
UINT MATLABNamespace::MATLABFunctionThreader::createMATLABThread(LPVOID pointerToDataWrapper)
{
 
  //create a new pointer on the inside the function 
 //and point it to the data location 'outside'
  MATLABDataWrapper *pointer = (MATLABDataWrapper *)pointerToDataWrapper;
 
//create data arrays
  mwArray mxInversions, mxSample, mxTime;
 
//call MATLAB function
  inverterFunction(3, mxInversions, mxSample, mxTime);
 
//access the memory outside the function, 
//and store the data values in appropriate slots.
  pointer->mxInversions = mxInversions;
  pointer->mxSample = mxSample;
  pointer->mxTime = mxTime;
 
//exit with 'success'
 return 0;
}

//create a data struct to store data in...
MATLABNamespace::MATLABDataWrapper dataContainer;
 
//start a worker thread
AfxBeginThread(MATLABNamespace::MATLABFunctionThreader::createMATLABThread,
               &dataContainer,//address of data container is passed in as LPVOID
               THREAD_PRIORITY_NORMAL); //assume normal thread priority...