Documentation

#define EXPORT

#include "Student.hpp"


Student::Student() : rollNumber(0) {}

Student::Student(int rollNo) : rollNumber(rollNo) {}

int Student::getRollNumber() {
    return rollNumber;
}

DLL_EXPORT void readStudents(const std::stack<Student>& students) {
}

DLL_EXPORT std::stack<Student> getStudents(int size) {
    std::stack<Student> students;
    for (int i = 0; i < size; i++) {
        students.push(Student(i+1));
    }
    return students;
}

//Wrapper header to access/pass std::stack objects from MATLAB
#ifndef stack_header
#define stack_header

#include <stack>
#include <stdexcept>

template<typename T>
class CStack {
    std::stack<T> data;
public:
    CStack() {}
    
    // This parameterized constructor is required for the wrapper functions
    // and is not included in the MATLAB interface
    CStack(const std::stack<T>& d):data(d) {} 

    // Function to access the topmost element in stack
    T* get() {
        if (data.empty())
            throw std::runtime_error("Retrieving element from Empty Stack");
        return &data.top();
    }
    
    // Function to remove elements from stack
    void remove() { 
        if (data.empty())
            throw std::runtime_error("Stack is empty");
        data.pop();
    }
    
    // Function to add elements to stack
    void add(const T* element) { 
        data.push(*element);
    }
    
    // This method is required for the wrapper functions, and
    // is not included in the MATLAB interface
    const std::stack<T>& getData() const{ 
        return data;
    }
};
#endif

//Header to call readStudents and getStudents functions from MATLAB
#include "Student.hpp"
#include "CStack.hpp"

//wrapper function to access the function that accepts std::stack input
void readStudentsWrapper(const CStack<Student>& students) { 
    readStudents(students.getData());
}

//wrapper function to access the function that returns the std::stack
CStack<Student> getStudentsWrapper(int size) { 
    auto students = getStudents(size);
    CStack<Student> cstackStudents(students);
    return cstackStudents;
}

//Wrapper to instantiate template class Pairs
#include "Templates.hpp"

/* Data types that will be used for Pairs class. */
template class Pairs<int>;
template class Pairs<double>;

#define EXPORT

#include "ContentHidden.hpp"

DLL_EXPORT void* getObjWithContentHidden() {
    std::vector<int> *vecData = new std::vector<int>({1,2,3,4});
    return vecData;
}
DLL_EXPORT unsigned int sizeOfObjWithContentHidden(void* pobj) {
    return (static_cast<std::vector<int> *> (pobj))->size();
}

//Wrapper to access function with void* as argument/return type
#pragma once
#include "ContentHidden.hpp"

class VoidType {};  //wrapper class to convert void* to VoidType*

VoidType* getObjWrapper() {
    return static_cast<VoidType*> (getObjWithContentHidden());
}

unsigned int sizeOfObjWrapper(VoidType* pobj) {
    return sizeOfObjWithContentHidden(pobj);
}

#define EXPORT

#include "CreateTrackbar.hpp"
#include <iostream>

DLL_EXPORT int cvCreateTrackbar(const char *trackbar_name, const char *window_name, int *value, int count, CvTrackbarCallback on_change = NULL){
    return count;
}	

DLL_EXPORT void MatchingMethod(int, void*){
    std::cout << "Invoked Function : MatchingMethod" << std::endl;
}

// Wrapper Header to access function pointer CvTrackbarCallback
#include "CreateTrackbar.hpp"

using CvTrackbarCallback = void (*) (int , void *);

class CvTrackbarCallbackWrapper {
public:
    CvTrackbarCallback const on_change;
    CvTrackbarCallbackWrapper(CvTrackbarCallback fptr) : on_change(fptr) {}
};

template<CvTrackbarCallback fptr>
class CvTrackbarCallbackWrapperTempl : public CvTrackbarCallbackWrapper {
public:
    CvTrackbarCallbackWrapperTempl() : CvTrackbarCallbackWrapper(fptr){}
};

template class CvTrackbarCallbackWrapperTempl<MatchingMethod>;

// Wrapper function to access the function that accepts function pointer input
int wrapperTrackbar(const char *trackbar_name, 
        const char *window_name, int *value, int count, 
        CvTrackbarCallbackWrapper const &callbackWrapper) {
    
    return cvCreateTrackbar(trackbar_name, window_name, value, count, callbackWrapper.on_change);
}

defineArgument(wrapperTrackbarDefinition, "trackbar_name", "string", "input", "nullTerminated");

defineArgument(wrapperTrackbarDefinition, "window_name", "string", "input", "nullTerminated");

defineArgument(wrapperTrackbarDefinition, "value", 'int32', "input", 1);

#define EXPORT

#include "Area.hpp"

DLL_EXPORT double getArea(int radius, double piVal) {
    return piVal*radius*radius;
}

//Wrapper to access the preprocessor directive value
#include "Area.hpp"

double getPI(){ //Wrapper function retrieves the value of PI
    return PI;
}

#define EXPORT

#include "StringVector.hpp"

DLL_EXPORT void readStringVector(const std::vector<std::string>& stringVector) {
}

DLL_EXPORT std::vector<std::string> getStringVector(int size) {
    std::vector<std::string> stringVector;
    for (int i = 0; i < size; i++) {
       stringVector.push_back(("string"+ std::to_string(i+1)));
    }
    return stringVector;
}

//Wrapper header to access/pass std::vector from MATLAB
#ifndef cvector_header
#define cvector_header

#include <vector>

template<typename T>
class CVector {
    std::vector<T> data;
public:
    CVector() {}
    CVector(const std::vector<T>& d): data(d) {}
    CVector(std::vector<T>&& d) : data(std::move(d)) {}
    T get(int index) { 
        return data.at(index-1);
    }
    void add(const T& element) { 
        data.push_back(element);
    }
    const std::vector<T>& getData() const {
        return data;
    }
};

#endif

// Header that allows the readStringVector and getStringVector functions 
// to be accessed from MATLAB interface
#include "StringVector.hpp"
#include "CVector.hpp"
#include <string>

void wrapperReadStringVector(const CVector<std::string>& stringVec) { 
    readStringVector(stringVec.getData());
}

CVector<std::string> wrapperGetStringVector(int size) { 
    auto strVec = getStringVector(size);
    CVector<std::string> cvecString(strVec);
    return cvecString;
}