void Game::getBetFromPlayer(GamePlayer &p) {
const double MAX_ALLOWABLE_BET_FROM_PLAYER = p.getMaxBetAllowed(MIN_ALLOWABLE_BET, MAX_ALLOWABLE_BET);
if (p.isInSession() == true) {
std::cout << p.getName(false) << " has " << p.getMoney() << "." << std::endl;
std::cout << "Please enter an amount upto " << MAX_ALLOWABLE_BET_FROM_PLAYER << std::endl;
std::cout << "$";
double bet;
/*
player will be allowed to input 0 in order to not play round. min. bet should be five and max should be 500(or 50)
*/
while ( (bet = getDoubleInput(false)) > MAX_ALLOWABLE_BET_FROM_PLAYER || (bet < 5 && bet > 0) ) {
std::cout << "Type 0 to skip round or input a bet not more then " << MAX_ALLOWABLE_BET_FROM_PLAYER << ": ";
}
if (bet == 0) {
std::cout << p.getName(false) << " is out." << std::endl;
p.setInSession(false);
}
std::cout << p.getName(false) << " after a bet of " << p.getBet() << " has " ;
p.setMoney(p.getMoney() - bet);
std::cout << p.getMoney() << "." << std::endl;
}
else {
std::cout << p.getName(false) << " cannot bet the min bet and is out." << std::endl;
p.setInSession(false);
}
}
void Game::getBetsFromAllPlayers(std::vector<GamePlayer*> &p) {
//do demo mode a.i. here for determining bets?
if (DEBUGGING) {
std::cout << "DEBUG: Game::getBetsFromAllPlayers start" << std::endl;
std::cout << "Players size is " << p.size() << std::endl;
}
for (size_t pCounter = 0; pCounter < p.size(); pCounter++) {
p[pCounter]->setPreBetMoney();
const double MAX_ALLOWABLE_BET_FROM_PLAYER = p[pCounter]->getMaxBetAllowed(MIN_ALLOWABLE_BET, MAX_ALLOWABLE_BET);
if (DEBUGGING) {
std::cout << p[pCounter]->getName() << " session status: " << p[pCounter]->isInSession() << std::endl;
}
if (p[pCounter]->isInSession() == true) {
std::cout << p[pCounter]->getName(false) << " has " << p[pCounter]->getMoney() << "." << std::endl;
std::cout << "Please enter an amount upto " << MAX_ALLOWABLE_BET_FROM_PLAYER << std::endl;
std::cout << "$";
double bet;
/*
player will be allowed to input 0 in order to not play round. min. bet should be five and max should be 500(or 50)
*/
while ( (bet = getDoubleInput(false)) > MAX_ALLOWABLE_BET_FROM_PLAYER || (bet > 0 && bet < 5) ) {
std::cout << "Type 0 to skip round or input a bet more then $" << MIN_ALLOWABLE_BET << " and upto $" << MAX_ALLOWABLE_BET_FROM_PLAYER << ": ";
}
p[pCounter]->setBet(bet);
if (bet == 0) {
std::cout << p[pCounter]->getName(false) << " is out." << std::endl;
p[pCounter]->setInSession(false);
p[pCounter]->setBet(0);
}
std::cout << p[pCounter]->getName(false) << " before bet had " << p[pCounter]->getMoney() << " and after bet has ";
std::cout << p[pCounter]->getMoney() << " - " << p[pCounter]->getBet() << " = " << p[pCounter]->getMoney() - p[pCounter]->getBet() << std::endl;
p[pCounter]->setMoney(p[pCounter]->getMoney() - p[pCounter]->getBet());
std::cout << std::endl;
}
else {
std::cout << p[pCounter]->getName(false) << "is not in session and therefore cannot participate." << std::endl;
p[pCounter]->setInSession(false);
}
}
//std::cout << "END";
/* this method probably does too much. It probably shouldn't change the session but return an error sentinel per player?
May change getting all players bets to getting individual players bets, like a loop in main or from a fuction in main
*/
//std::cout << "DEBUG: game::getBetsFromAllPlayers: at the end of getbetsfromallplayers, money is " << p[0]->getMoney() << std::endl;
}
//=========================================================================
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//Documentation of the calling forms is given within each if clause
if (!locked)
{
//NOTE: If we run clear all this will clear the definition of
//this file and depending on whether or not we had open references
//could cause Matlab to crash. By locking this file we prevent
//clearing the file (which means we can't recompile it unless we
//close Matlab) but we also prevent Matlab from crashing.
//
//TODO: Implement allowing unlock by reference counting
//TODO: Alternatively we could pass in a command to unlock
mexLock();
locked = 1;
}
ADI_FileHandle fileH(0);
//Setup output result code
//-----------------------------------------------
//Each function returns a result code, indicating if the function call
//worked or not.
ADIResultCode result;
int *out_result; //Each function will return a result code as well as
//possibly other values ..
plhs[0] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL);
out_result = (int *) mxGetData(plhs[0]);
//Which function to call
double function_option = mxGetScalar(prhs[0]);
//Function list
//--------------------------------------
// 0 ADI_OpenFile
// 1 ADI_GetNumberOfRecords
// 2 ADI_GetNumberOfChannels
// 3 ADI_GetNumTicksInRecord
// 4 ADI_GetRecordTickPeriod
// 5 ADI_GetNumSamplesInRecord
// 6 ADI_CreateCommentsAccessor
// 7 ADI_CloseCommentsAccessor
// 8 ADI_GetCommentInfo
// 9 ADI_NextComment
// 10 ADI_GetSamples
// 11 ADI_GetUnitsName
// 12 ADI_GetChannelName
// 13 ADI_CloseFile
// 14 ADI_GetErrorMessage
// 15 ADI_GetRecordSamplePeriod
// 16 ADI_GetRecordTime
// 17 ADI_CreateFile
if (function_option == 0)
{
// ADI_OpenFile <> openFile
// ===================================================
// [result_code,file_h] = sdk_mex(0,file_path)
wchar_t *w_file_path = (wchar_t *)mxGetData(prhs[1]);
//long openMode = getLongInput(prhs,2);
result = ADI_OpenFile(w_file_path, &fileH, kOpenFileForReadOnly);
out_result[0] = result;
setFileHandle(plhs,result,fileH);
}
else if (function_option == 0.5)
{
//This is a call to open the file for reading and writing
//
//TODO: Replace this with an input to function 0
wchar_t *w_file_path = (wchar_t *)mxGetData(prhs[1]);
result = ADI_OpenFile(w_file_path, &fileH, kOpenFileForReadAndWrite);
out_result[0] = result;
setFileHandle(plhs,result,fileH);
}
else if (function_option == 1)
{
// ADI_GetNumberOfRecords <> getNumberOfRecords
// ======================================================
// [result_code,n_records] = sdk_mex(1,file_handle)
long nRecords = 0;
fileH = getFileHandle(prhs);
//ADIResultCode ADI_GetNumberOfRecords(ADI_FileHandle fileH, long* nRecords);
result = ADI_GetNumberOfRecords(fileH,&nRecords);
out_result[0] = result;
setLongOutput(plhs,1,nRecords);
}
else if (function_option == 2)
{
// ADI_GetNumberOfChannels <> getNumberOfChannels
// ========================================================
// [result_code,n_channels] = sdk_mex(2,file_handle)
long nChannels = 0;
fileH = getFileHandle(prhs);
//ADIResultCode ADI_GetNumberOfChannels(ADI_FileHandle fileH, long* nChannels);
result = ADI_GetNumberOfChannels(fileH,&nChannels);
out_result[0] = result;
setLongOutput(plhs,1,nChannels);
}
else if (function_option == 3)
{
// ADI_GetNumTicksInRecord <> getNTicksInRecord
// ======================================================
// [result,n_ticks] = sdk_mex(3,file_handle,record_idx_0b)
fileH = getFileHandle(prhs);
//0 or 1 based ...
long record = getLongInput(prhs,2);
long nTicks = 0;
//ADIResultCode ADI_GetNumTicksInRecord(ADI_FileHandle fileH, long record, long* nTicks);
result = ADI_GetNumTicksInRecord(fileH,record,&nTicks);
out_result[0] = result;
setLongOutput(plhs,1,nTicks);
}
else if (function_option == 4)
{
// ADI_GetRecordTickPeriod <> getTickPeriod
// =========================================================
// [result,s_per_tick] = sdk_mex(4,file_handle,record_idx_0b,channel_idx_0b)
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
long channel = getLongInput(prhs,3);
double secsPerTick = 0;
//ADIResultCode ADI_GetRecordTickPeriod(ADI_FileHandle fileH, long channel, long record, double* secsPerTick);
out_result[0] = ADI_GetRecordTickPeriod(fileH,channel,record,&secsPerTick);
setDoubleOutput(plhs,1,secsPerTick);
}
else if (function_option == 5)
{
// ADI_GetNumSamplesInRecord <> getNSamplesInRecord
// ========================================================
// [result_code,n_samples] = sdk_mex(5,file_handle,record_idx_0b,channel_idx_0b);
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
long channel = getLongInput(prhs,3);
long nSamples = 0;
//ADIResultCode ADI_GetNumSamplesInRecord(ADI_FileHandle fileH, long channel, long record, long* nSamples);
out_result[0] = ADI_GetNumSamplesInRecord(fileH,channel,record,&nSamples);
setLongOutput(plhs,1,nSamples);
}
else if (function_option == 6)
{
// ADI_CreateCommentsAccessor <> getCommentAccessor
// ========================================================
// [result_code,comments_h] = sdk_mex(6,file_handle,record_idx_0b);
ADI_CommentsHandle commentsH(0);
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
//ADIResultCode ADI_CreateCommentsAccessor(ADI_FileHandle fileH, long record, ADI_CommentsHandle* commentsH);
result = ADI_CreateCommentsAccessor(fileH,record,&commentsH);
out_result[0] = result;
int64_t *p_c;
plhs[1] = mxCreateNumericMatrix(1,1,mxINT64_CLASS,mxREAL);
p_c = (int64_t *) mxGetData(plhs[1]);
if (result == 0)
p_c[0] = (int64_t)commentsH;
else
p_c[0] = 0;
}
else if (function_option == 7)
{
// ADI_CloseCommentsAccessor <> closeCommentAccessor
// ========================================================
// result_code = sdk_mex(7,comments_h);
ADI_CommentsHandle commentsH = getCommentsHandle(prhs);
//ADIResultCode ADI_CloseCommentsAccessor(ADI_CommentsHandle *commentsH);
out_result[0] = ADI_CloseCommentsAccessor(&commentsH);
}
else if (function_option == 8)
{
// ADI_GetCommentInfo <> getCommentInfo
// ====================================================
// [result_code,comment_string,comment_length,tick_pos,channel,comment_num] = sdk_mex(8,comment_h)
//
// Status: Done
ADI_CommentsHandle commentsH = getCommentsHandle(prhs);
wchar_t *messageOut = getStringOutputPointer(plhs,1);
long tickPos = 0;
long channel = 0;
long commentNum = 0;
long textLen = 0;
//ADIResultCode ADI_GetCommentInfo(ADI_CommentsHandle commentsH, long *tickPos, long *channel, long *commentNum, wchar_t* text,long maxChars, long *textLen);
// tickPos - receives the tick position of the comment in the record [outparam]
// commentNum - receives the number of the comment [outparam]
// channel - receives the channel of the comment (-1 for all channel comments) [outparam]
// text - buffer to receive null terminated text for the comment (optional, may be NULL) [outparam]
// maxChars - the size of the text buffer in wchar_t s. The text will be truncated to fit in this size
// textLen - receives the number of characters needed to hold the full comment text,
// even if parameter text is NULL (optional, may be NULL) [outparam]
out_result[0] = ADI_GetCommentInfo(commentsH,&tickPos,&channel,&commentNum,messageOut,MAX_STRING_LENGTH,&textLen);
setLongOutput(plhs,2,textLen);
setLongOutput(plhs,3,tickPos);
setLongOutput(plhs,4,channel);
setLongOutput(plhs,5,commentNum);
}
else if (function_option == 9)
{
// ADI_NextComment <> advanceComments
// ==================================================
// result_code = adi.sdk_mex(9,comments_h);
//
// Returns kResultNoData if there are no more comments ...
//
// Status: Done
ADI_CommentsHandle commentsH = getCommentsHandle(prhs);
//ADIResultCode ADI_NextComment(ADI_CommentsHandle commentsH);
out_result[0] = ADI_NextComment(commentsH);
}
else if (function_option == 10)
{
// ADI_GetSamples <> getChannelData
// ===========================================================
// [result,data,n_returned] = sdk_mex(10,file_h,channel_0b,record_0b,startPos,nLength,dataType)
fileH = getFileHandle(prhs);
long channel = getLongInput(prhs,2);
long record = getLongInput(prhs,3);
long startPos = getLongInput(prhs,4);
long nLength = getLongInput(prhs,5);
ADICDataFlags dataType = static_cast<ADICDataFlags>(getLongInput(prhs,6));
plhs[1] = mxCreateNumericMatrix(1,(mwSize)nLength,mxSINGLE_CLASS,mxREAL);
float *data = (float *)mxGetData(plhs[1]);
long returned = 0;
// Retrieves a block of sample data from the file into a buffer. Samples are in physical
// prefixed units.
//DLLEXPORT ADIResultCode ADI_GetSamples(ADI_FileHandle fileH, long channel, long record, long startPos,
// ADICDataFlags dataType, long nLength, float* data, long* returned);
out_result[0] = ADI_GetSamples(fileH,channel,record,startPos,dataType,nLength,data,&returned);
//out_result[0] = ADI_GetSamples(fileH,channel,record,startPos,kADICDataAtSampleRate,nLength,data,&returned);
setLongOutput(plhs,2,returned);
//out_result[0] = 4;
}
else if (function_option == 11)
{
// ADI_GetUnitsName <> getUnits
// =======================================
// [result_code,str_data,str_length] = sdk_mex(11,file_h,record,channel);
//Inputs
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
long channel = getLongInput(prhs,3);
//Outputs
long textLen = 0;
wchar_t *unitsOut = getStringOutputPointer(plhs,1);
// Retrieves the prefixed units of a channel, as a string.
//
//ADIResultCode ADI_GetUnitsName(ADI_FileHandle fileH, long channel, long record, wchar_t* units, long maxChars, long *textLen);
out_result[0] = ADI_GetUnitsName(fileH, channel, record, unitsOut, MAX_STRING_LENGTH, &textLen);
setLongOutput(plhs,2,textLen);
}
else if (function_option == 12)
{
// ADI_GetChannelName <> getChannelName
// =============================================
// [result_code,str_data,str_length] = sdk_mex(12,file_h,channel);
//Inputs
fileH = getFileHandle(prhs);
long channel = getLongInput(prhs,2);
//Outputs
long textLen = 0;
wchar_t *nameOut = getStringOutputPointer(plhs,1);
// Retrieves the name of a channel, as a string.
//ADIResultCode ADI_GetChannelName(ADI_FileHandle fileH, long channel, wchar_t* name, long maxChars, long *textLen);
out_result[0] = ADI_GetChannelName(fileH, channel, nameOut, MAX_STRING_LENGTH, &textLen);
setLongOutput(plhs,2,textLen);
}
else if (function_option == 13)
{
// ADI_CloseFile <> closeFile
// ==============================================================
//
fileH = getFileHandle(prhs);
result = ADI_CloseFile(&fileH);
out_result[0] = result;
}
else if (function_option == 14)
{
// ADI_GetErrorMessage <> getErrorMessage
// ==============================================================
// err_msg = sdk_mex(14,error_code)
long textLen = 0;
wchar_t *messageOut = getStringOutputPointer(plhs,1);
ADIResultCode code = (ADIResultCode)getLongInput(prhs,1);
//ADIResultCode ADI_GetErrorMessage(ADIResultCode code, wchar_t* messageOut, long maxChars, long *textLen);
out_result[0] = ADI_GetErrorMessage(code, messageOut, MAX_STRING_LENGTH, &textLen);
setLongOutput(plhs,2,textLen);
}
else if (function_option == 15)
{
// ADI_GetRecordSamplePeriod <> getSamplePeriod
// ==============================================================
// [result_code,dt_channel] = sdk_mex(15,file_h,record,channel)
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
long channel = getLongInput(prhs,3);
double secsPerSample = 0;
out_result[0] = ADI_GetRecordSamplePeriod(fileH, channel, record, &secsPerSample);
setDoubleOutput(plhs,1,secsPerSample);
}
else if (function_option == 16)
{
// ADI_GetRecordTime <> getRecordStartTime
// ==============================================================
// [result_code,trigger_time,frac_secs,trigger_minus_rec_start] = sdk_mex(16,file_h,record)
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
time_t triggerTime = 0;
double fracSecs = 0;
long triggerMinusStartTicks = 0;
//Retrieves time information about the specified record.
//The trigger time is the time origin of the record and may differ from the start time if
//there is a pre or post trigger delay, as specified by the trigMinusRecStart parameter.
// Params: fileH - ADI_FileHandle for the open file
// record - the record index (starting from 0)
// triggerTime - time_t receives the date and time of the trigger
// position for the new record. Measured as number of
// seconds from 1 Jan 1970
// fracSecs - receives the fractional seconds part of
// the record trigger time ('triggerTime' parameter)
// trigMinusRecStart - trigger-time-minus-record-start-ticks. Receives the
// difference between the time of trigger tick and the first
// tick in the record. This +ve for pre-trigger delay and
// -ve for post-trigger delay.
// Return: a ADIResultCode for result of the operation
//DLLEXPORT ADIResultCode ADI_GetRecordTime(ADI_FileHandle fileH, long record, time_t *triggerTime,
//double *fracSecs, long *triggerMinusStartTicks);
out_result[0] = ADI_GetRecordTime(fileH, record, &triggerTime, &fracSecs, &triggerMinusStartTicks);
setDoubleOutput(plhs,1,(double)triggerTime);
setDoubleOutput(plhs,2,fracSecs);
setLongOutput(plhs,3,triggerMinusStartTicks);
}
else if (function_option == 17){
//
// ADI_CreateFile <> createFile
// ==============================================================
// [result_code,file_h] = sdk_mex(17,file_path)
//
// Implemented via sdk.createFile
wchar_t *w_file_path = (wchar_t *)mxGetData(prhs[1]);
result = ADI_CreateFile(w_file_path, &fileH);
out_result[0] = result;
setFileHandle(plhs,result,fileH);
}
else if (function_option == 18){
//
// ADI_SetChannelName <> setChannelName
// ==============================================================
// [result_code,file_h] = sdk_mex(18,file_h,channel,name)
//
// Implemented via sdk.setChannelName
fileH = getFileHandle(prhs);
long channel = getLongInput(prhs,2);
wchar_t *channel_name = (wchar_t *)mxGetData(prhs[3]);
out_result[0] = ADI_SetChannelName(fileH, channel, channel_name);
}
else if (function_option == 19){
//
// ADI_CreateWriter <> createDataWriter
// ===========================================
// [result_code,writer_h] = sdk_mex(19,file_h)
//
// Implemented via sdk.createDataWriter
ADI_WriterHandle writerH(0);
fileH = getFileHandle(prhs);
result = ADI_CreateWriter(fileH,&writerH);
out_result[0] = result;
setWriterHandle(plhs,result,writerH);
}
else if (function_option == 20){
//
// ADI_SetChannelInfo <> setChannelInfo
// ===========================================
// [result_code] = sdk_mex(20,writer_h,channel,enabled,seconds_per_sample,units,limits)
//
// implemented via adi.sdk.setChannelInfo
ADI_WriterHandle writerH = getWriterHandle(prhs);
long channel = getLongInput(prhs,2);
int enabled = getIntInput(prhs,3);
double seconds_per_sample = getDoubleInput(prhs,4);
wchar_t *units = (wchar_t *)mxGetData(prhs[5]);
float *temp_limits = (float *)mxGetData(prhs[5]);
ADIDataLimits limits;
limits.mMaxLimit = temp_limits[1];
limits.mMinLimit = temp_limits[0];
out_result[0] = ADI_SetChannelInfo(writerH, channel, enabled, seconds_per_sample, units, &limits);
// DLLEXPORT ADIResultCode ADI_SetChannelInfo(ADI_WriterHandle writerH, long channel, int enabled,
// double secondsPerSample, const wchar_t* units, const ADIDataLimits *limits);
}
else if (function_option == 21){
//
// ADI_StartRecord <> startRecord
// ===========================================
// result_code = sdk_mex(21, writerH, trigger_time, fractional_seconds, trigger_minus_rec_start)
//
// implemented via adi.sdk.startRecord
ADI_WriterHandle writerH = getWriterHandle(prhs);
time_t trigger_time = (time_t)getDoubleInput(prhs,2);
double fractional_seconds = getDoubleInput(prhs,3);
long trigger_minus_rec_start = getLongInput(prhs,4);
out_result[0] = ADI_StartRecord(writerH, trigger_time, fractional_seconds, trigger_minus_rec_start);
// DLLEXPORT ADIResultCode ADI_StartRecord(ADI_WriterHandle writerH, time_t triggerTime,
// double fracSecs, long triggerMinusStartTicks);
}
else if (function_option == 22){
//
// ADI_AddChannelSamples <> addChannelSamples
// ===========================================
// [result_code,new_ticks_added] = sdk_mex(22, writerH, channel, data, n_samples)
//
// adi.sdk.addChannelSamples
ADI_WriterHandle writerH = getWriterHandle(prhs);
long channel = getLongInput(prhs,2);
float *data = (float *)mxGetData(prhs[3]);
long n_samples = (long)mxGetNumberOfElements(prhs[3]);
long new_ticks_added = 0;
out_result[0] = ADI_AddChannelSamples(writerH, channel, data, n_samples, &new_ticks_added);
setLongOutput(plhs,1,new_ticks_added);
// DLLEXPORT ADIResultCode ADI_AddChannelSamples(ADI_WriterHandle writerH, long channel,
// float* data, long nSamples, long *newTicksAdded);
}
else if (function_option == 23){
//
// ADI_FinishRecord <> finishRecord
// ===========================================
// [result_code] = sdk_mex(23, writerH)
//
// Implemented via adi.sdk.finishRecord
ADI_WriterHandle writerH = getWriterHandle(prhs);
out_result[0] = ADI_FinishRecord(writerH);
// DLLEXPORT ADIResultCode ADI_FinishRecord(ADI_WriterHandle writerH);
}
else if (function_option == 24){
//
// ADI_CommitFile <> commitFile
// ===========================================
// [result_code] = sdk_mex(24, writerH, flags)
//
// Implemented via adi.sdk.commitFile
ADI_WriterHandle writerH = getWriterHandle(prhs);
//TODO: What are the flags??????
out_result[0] = ADI_CommitFile(writerH, 0);
// DLLEXPORT ADIResultCode ADI_CommitFile(ADI_WriterHandle writerH, long flags);
}
else if (function_option == 25){
//
// ADI_CloseWriter <> closeWriter
// ===========================================
// [result_code] = sdk_mex(25, writerH)
//
// Implemented via adi.sdk.closeWriter
ADI_WriterHandle writerH = getWriterHandle(prhs);
out_result[0] = ADI_CloseWriter(&writerH);
// DLLEXPORT ADIResultCode ADI_CloseWriter(ADI_WriterHandle *writerH);
}
else if (function_option == 26){
//
// ADI_AddComment <> addComment
// ===========================================
// [result_code, comment_number] =
// sdk_mex(26, file_h, channel, record, tick_position, text)
//
// Implemented via adi.sdk.addComment
fileH = getFileHandle(prhs);
long channel = getLongInput(prhs,2);
long record = getLongInput(prhs,3);
long tick_position = getLongInput(prhs,4);
wchar_t *text = (wchar_t *)mxGetData(prhs[5]);
long comment_number = 0;
//long comment_number = getLongInput(prhs,6);
out_result[0] = ADI_AddComment(fileH, channel, record, tick_position, text, &comment_number);
setLongOutput(plhs,1,comment_number);
// DLLEXPORT ADIResultCode ADI_AddComment(ADI_FileHandle fileH, long channel, long record, long tickPos,
// const wchar_t* text, long* commentNum);
}
else if (function_option == 27){
//
// ADI_DeleteComment <> deleteComment
// ===========================================
// result_code = sdk_mex(27,file_h,comment_number)
//
// Implemented via adi.sdk.deleteComment
fileH = getFileHandle(prhs);
long comment_number = getLongInput(prhs,2);
out_result[0] = ADI_DeleteComment(fileH,comment_number);
// DLLEXPORT ADIResultCode ADI_DeleteComment(ADI_FileHandle fileH, long commentNum);
}
else if (function_option == 100){
mexUnlock();
locked = 0;
}
else
{
mexErrMsgIdAndTxt("adinstruments:sdk_mex",
"Invalid function option");
}
//ADI_GetRecordSamplePeriod
//ADI_GetRecordTime
}
