主采集逻辑修改中，添加了部分写文件实现

source/FS/ATPDataFileProcessor.h

@@ -1 +0,0 @@
-#pragma once

source/FS/DataFileProcessor.cpp

@@ -0,0 +1,125 @@
+#include "DataFileProcessor.h"
+
+DataFileProcessor::DataFileProcessor()
+{
+#ifdef _DEBUG
+	m_qstrFilePath = "E:/WorkSpace/TowerOptoSifAndSpectral/Data";
+#else
+	m_qstrFilePath = /home/data/Data;
+#endif // DEBUG
+	
+}
+
+DataFileProcessor::~DataFileProcessor()
+{
+}
+
+void DataFileProcessor::SetEnvironmentContex(EContext struEC)
+{
+	m_struEC = struEC;
+}
+
+void DataFileProcessor::SetManmadeEnviromentalContext(MEContext struMEC)
+{
+	m_struMEC = struMEC;
+}
+
+bool DataFileProcessor::WriteDataFile()
+{
+	GenerateFilePath();
+	WriteInfo();
+	bool res = true;
+	return res;
+}
+
+void DataFileProcessor::GenerateFilePath()
+{
+    m_qdtTime = QDateTime::currentDateTime();
+	QString qstrAddYMD = m_qdtTime.toString("/yyyy_MM_dd");
+	QString qstrAddHMS = m_qdtTime.toString("_hh_mm_ss");
+
+	m_struEC.qstrUTCDateTime = m_qdtTime.toUTC().toString("yyyy_MM_dd hh:mm:ss");
+
+	m_qstrFullFileName = m_qstrFilePath + qstrAddYMD;
+	m_qstrFilePath= m_qstrFullFileName;
+	if (m_struEC.qstrLocation=="")
+	{
+		m_struEC.qstrLocation = "Unknown";
+	}
+	m_qstrFullFileName= m_qstrFullFileName+"/"+m_struEC.qstrLocation + qstrAddHMS+".txt";
+
+	QDir qdirPath(m_qstrFilePath);
+	if (!qdirPath.exists())
+	{
+		qdirPath.mkdir(m_qstrFilePath);
+	}
+}
+
+bool DataFileProcessor::WriteInfo()
+{
+	bool bRes = true;
+	QFile qfData(m_qstrFullFileName);
+	bRes = qfData.open(QFile::WriteOnly|QFile::Text|QFile::Truncate);
+	if (!bRes)
+	{
+		return bRes;
+	}
+	//EC
+	qfData.write("EnvironmentalContext,");
+	qfData.write("CaseHumidity,");
+	qfData.write(m_struEC.qstrCaseHumidity.toLatin1());
+	qfData.write(",");
+	qfData.write("CaseTemperature,");
+	qfData.write(m_struEC.qstrCaseTemperature.toLatin1());
+	qfData.write(",");
+	qfData.write("GPS_Altitude,");
+	qfData.write(m_struEC.qstrGPS_Altitude.toLatin1());
+	qfData.write(",");
+	qfData.write("GPS_Latitude,");
+	qfData.write(m_struEC.qstrGPS_Latitude.toLatin1());
+	qfData.write(",");
+	qfData.write("GPS_Longtitude,");
+	qfData.write(m_struEC.qstrGPS_Longtitude.toLatin1());
+	qfData.write(",");
+	qfData.write("GPS_North,");
+	qfData.write(m_struEC.qstrGPS_North.toLatin1());
+	qfData.write(",");
+	qfData.write("Location,");
+	qfData.write(m_struEC.qstrLocation.toLatin1());
+	qfData.write(",");
+	qfData.write("UTCDateTime,");
+	qfData.write(m_struEC.qstrUTCDateTime.toLatin1());
+	qfData.write(",");
+
+	//qfData.write("\n");
+
+	//MEC
+	//qfData.write("ManmadeEnvironmentalContext\n");
+	qfData.write("DownlaodAddress,");
+	qfData.write(m_struMEC.qstrDownlaodAddress.toLatin1());
+	qfData.write(",");
+	qfData.write("DownloadUserID,");
+	qfData.write(m_struMEC.qstrDownloadUserID.toLatin1());
+	qfData.write(",");
+	qfData.write("HTTPServer,");
+	qfData.write(m_struMEC.qstrHTTPServer.toLatin1());
+	qfData.write(",");
+	qfData.write("InstallationTime,");
+	qfData.write(m_struMEC.qstrInstallationTime.toLatin1());
+	qfData.write(",");
+	qfData.write("NameOfMaintenanceStaff,");
+	qfData.write(m_struMEC.qstrNameOfMaintenanceStaff.toLatin1());
+	qfData.write(",");
+	qfData.write("PhoneNumberOfMaintenanceStaff,");
+	qfData.write(m_struMEC.qstrPhoneNumberOfMaintenanceStaff.toLatin1());
+	qfData.write(",");
+
+	qfData.close();
+	return bRes;
+}
+
+bool DataFileProcessor::WriteData()
+{
+	bool res = true;
+	return res;
+}

source/FS/DataFileProcessor.h

@@ -0,0 +1,28 @@
+#pragma once
+#include "pch.h"
+#include "ZZ_Types.h"
+using namespace ZZ_MISCDEF::ZZ_DATAFILE;
+class DataFileProcessor
+{
+public:
+	DataFileProcessor();
+	virtual ~DataFileProcessor();
+public:
+	void SetEnvironmentContex(EContext struEC);
+	void SetManmadeEnviromentalContext(MEContext truMEC);
+	bool WriteDataFile();
+private:
+	void GenerateFilePath();
+	bool WriteInfo();
+	bool WriteData();
+
+
+public:
+private:
+	QString m_qstrFullFileName;
+	QString m_qstrFileName;
+	QString m_qstrFilePath;
+	EContext m_struEC;
+	MEContext m_struMEC;
+	QDateTime m_qdtTime;
+};

source/FS/OControl_USB.cpp

@@ -0,0 +1,437 @@
+#include "OControl_USB.h"
+#include <iostream>
+#include <cstring>
+
+OceanOptics_lib::OceanOptics_lib()
+{
+	m_iSpectralmeterHandle = -100;
+}
+OceanOptics_lib::~OceanOptics_lib()
+{
+
+}
+
+//ʹ<><CAB9>ͷ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>#include "api/SeaBreezeWrapper.h"
+int OceanOptics_lib::Initialize(bool bIsUSBMode, ZZ_U8 ucPortNumber, std::string strDeviceName)
+{
+	int flag;
+	int error;
+	//char type[16];
+	int device_count = 0;
+	int i;
+
+	for (i = 0; i < SEABREEZE_MAX_DEVICES; i++)
+	{
+		//printf("\nOpening spectrometer %d.\n", i);
+		flag = seabreeze_open_spectrometer(i, &error);
+		//printf("Open spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
+		if (0 == flag)
+		{
+			device_count++;
+		}
+		string sn = GetSerialNumber(i);
+
+		if (strcmp(sn.c_str(), strDeviceName.c_str()) == 0)
+		{
+			m_iSpectralmeterHandle = i;
+			//printf("\nfind!!!!!!!!!!!!\n");
+			break;
+		}
+		else
+		{
+			//printf("\nClosing spectrometer %d.\n", i);
+			flag = seabreeze_close_spectrometer(i, &error);
+			//printf("Close spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
+		}
+	}
+
+	if (m_iSpectralmeterHandle == -100)
+	{
+		//printf("\nNo!!!!!!!!!!!!\n");
+		return 1;
+	}
+
+
+
+	//<2F><><EFBFBD>ó<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
+	long minimum_time;
+
+	minimum_time = seabreeze_get_min_integration_time_microsec(m_iSpectralmeterHandle, &error);
+	//printf("...Minimum is %ld microseconds, result is [%s]\n", minimum_time, get_error_string(error));
+	if (minimum_time < 0) {
+		/* If there was an error, reset to a time that is supported widely. */
+		minimum_time = 15000;
+		return 1;
+	}
+
+	//SetExposureTime(minimum_time);
+
+	return 0;
+}
+
+//ʹ<><CAB9>ͷ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>#include "api/SeaBreezeWrapper.h"
+int OceanOptics_lib::Initialize()
+{
+	int flag;
+	int error;
+	//char type[16];
+	int device_count = 0;
+	int i;
+
+	for (i = 0; i < SEABREEZE_MAX_DEVICES; i++)
+	{
+		//printf("\nOpening spectrometer %d.\n", i);
+		flag = seabreeze_open_spectrometer(i, &error);
+		//printf("Open spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
+		if (0 == flag)
+		{
+			m_iSpectralmeterHandle = i;
+			break;
+		}
+	}
+
+	if (m_iSpectralmeterHandle == -100)
+	{
+		//printf("\nNo!!!!!!!!!!!!\n");
+		return 1;
+	}
+
+	//<2F><><EFBFBD>ó<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
+	long minimum_time;
+
+	minimum_time = seabreeze_get_min_integration_time_microsec(m_iSpectralmeterHandle, &error);
+	//printf("...Minimum is %ld microseconds, result is [%s]\n", minimum_time, get_error_string(error));
+	if (minimum_time < 0) {
+		/* If there was an error, reset to a time that is supported widely. */
+		minimum_time = 15000;
+	}
+
+	SetExposureTime(minimum_time);
+
+	return 0;
+}
+
+
+//ʹ<><CAB9>ͷ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>#include "api/seabreezeapi/SeaBreezeAPI.h"
+//int OceanOptics_lib::Initialize(bool bIsUSBMode,ZZ_U8 ucPortNumber,std::string strDeviceName)
+//{
+//    int number_of_devices;
+//    long *device_ids;
+//    int i;
+//    int flag;
+//    int error = 0;
+//    char nameBuffer[80];
+//    char *serialNumber;
+//
+//
+////    /* Give the driver a chance to initialize itself */
+////    sbapi_initialize();
+//
+//    printf("Probing for devices...\n"); fflush(stdout);
+//    sbapi_probe_devices();
+//
+//    printf("Getting device count...\n"); fflush(stdout);
+//    number_of_devices = sbapi_get_number_of_device_ids();
+//    std::cout<<"Device count is "<< number_of_devices <<std::endl;
+//    if(0 == number_of_devices) {
+//        return 0;
+//    }
+//
+//    printf("Getting device IDs...\n");
+//    device_ids = (long *)calloc(number_of_devices, sizeof(long));
+//    number_of_devices = sbapi_get_device_ids(device_ids, number_of_devices);
+//    printf("Got %d device ID%s.\n", number_of_devices, number_of_devices == 1 ? "" : "s"); fflush(stdout);
+//
+//
+//    for(i = 0; i < number_of_devices; i++)
+//    {
+//        printf("%d: Device 0x%02lX:\n", i, device_ids[i]);
+////        printf("\tGetting device type...\n");
+//        flag = sbapi_get_device_type(device_ids[i], &error, nameBuffer, 79);
+////        printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
+//        if(flag > 0) {
+//            printf("\tDevice type: [%s]\n", nameBuffer);
+//        }
+//
+//        serialNumber = GetSerialNumber(device_ids[i]);
+//        serialNumber = GetSerialNumber(device_ids[i]);
+//
+//        printf("\tSerial number tc: [%s]\n", serialNumber);
+//
+////        /* Open the device */
+////        printf("\tAttempting to open:\n");
+////        flag = sbapi_open_device(device_ids[i], &error);
+////        printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
+////
+////        // jump to the next iteration if there was a problem
+////        if(flag != 0) {
+////            continue;
+////        }
+////
+////        // log deviations
+////        unsupportedFeatureCount=0;
+////        testFailureCount=0;
+////
+////        /* Test the device */
+////        for(test_index = 0; test_index < __test_function_count; test_index++) {
+////            /* Invoke each of the test functions against this device */
+////            __test_functions[test_index](device_ids[i], &unsupportedFeatureCount, &testFailureCount);
+////        }
+////
+////        /* Close the device */
+////        printf("\tAttempting to close:\n");
+////        sbapi_close_device(device_ids[i], &error);
+////        printf("\t\tResult is (%d) [%s]\n", flag, sbapi_get_error_string(error));
+////        printf("%d: Device 0x%02lX: \n\tNumber of unsupported features = %d\n\tNumber of test failures = %d\n", i, device_ids[i], unsupportedFeatureCount, testFailureCount);
+//    }
+//
+//    flag = sbapi_get_device_type(device_ids[i], &error, nameBuffer, 79);
+//
+//    return 1;
+//}
+
+//<2F>ر<EFBFBD><D8B1>豸
+void OceanOptics_lib::Close()
+{
+	int flag;
+	int error;
+
+	flag = seabreeze_close_spectrometer(m_iSpectralmeterHandle, &error);
+	//printf("Close spectrometer result is (%d) [%s]\n", flag, get_error_string(error));
+}
+
+//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݲɼ<DDB2>
+int OceanOptics_lib::SingleShot(DataFrame &dfData)
+{
+	if (m_iSpectralmeterHandle == -100)
+	{
+		//printf("\nNo!!!!!!!!!!!!\n");
+		return 1;
+	}
+
+	int error;
+	int flag;
+	int spec_length;
+	double *spectrum = 0;
+
+	//printf("\n\nGetting formatted spectrum length.\n");
+	spec_length = seabreeze_get_formatted_spectrum_length(m_iSpectralmeterHandle, &error);
+	//printf("Get formatted spectrum_length result is (%d) [%s]\n", spec_length, get_error_string(error));
+
+	if (spec_length > 0)
+	{
+		spectrum = (double *)calloc((size_t)spec_length, sizeof(double));
+
+		//printf("\nGetting a formatted spectrum.\n");
+		flag = seabreeze_get_formatted_spectrum(m_iSpectralmeterHandle, &error, spectrum, spec_length);
+		//printf("Get formatted spectrum result is (%d) [%s]\n", flag, get_error_string(error));
+		//printf("\tPixel value 20 is %1.2f\n", spectrum[20]);
+
+		for (int tmp = 0; tmp < spec_length; tmp++)
+		{
+			dfData.usData[tmp] = spectrum[tmp];
+		}
+
+		int exposureTimeInMS;
+		GetExposureTime(exposureTimeInMS);
+		dfData.usExposureTimeInMS = exposureTimeInMS;
+
+		float temperature;
+		GetDeviceTemperature(temperature);
+		dfData.fTemperature = temperature;
+
+		free(spectrum);
+	}
+
+	return 0;
+}
+
+//<2F><><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1>
+int OceanOptics_lib::SetExposureTime(int iExposureTimeInMS)
+{
+	iExposureTimeInMS = iExposureTimeInMS * 1000;
+	if (m_iSpectralmeterHandle == -100)
+	{
+		//printf("\nNo!!!!!!!!!!!!\n");
+		return 1;
+	}
+
+	int error;
+
+	seabreeze_set_integration_time_microsec(m_iSpectralmeterHandle, &error, iExposureTimeInMS);
+	//printf("Set integration time result is [%s]\n", get_error_string(error));
+
+	m_iExposureTime = iExposureTimeInMS;
+
+	return 0;
+}
+
+//<2F><>ȡ<EFBFBD>ع<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+int OceanOptics_lib::GetExposureTime(int &iExposureTimeInMS)
+{
+	if (m_iSpectralmeterHandle == -100)
+	{
+		//printf("\nNo!!!!!!!!!!!!\n");
+		return 1;
+	}
+
+	iExposureTimeInMS = m_iExposureTime;
+
+	return 0;
+}
+
+//<2F><><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD>¶<EFBFBD>
+int OceanOptics_lib::SetDeviceTemperature(float fTemperature)
+{
+	if (m_iSpectralmeterHandle == -100)
+	{
+		//printf("\nNo!!!!!!!!!!!!\n");
+		return 1;
+	}
+
+	int error;
+
+	//printf("\nSetting TEC temperature to -5C\n");
+	seabreeze_set_tec_temperature(m_iSpectralmeterHandle, &error, fTemperature);
+	//printf("Set tec temperature result is [%s]\n", get_error_string(error));
+
+	//printf("\nSetting TEC enable to true\n");
+	seabreeze_set_tec_enable(m_iSpectralmeterHandle, &error, 1);
+	//printf("Set tec enable result is [%s]\n", get_error_string(error));
+
+	return 0;
+}
+
+//<2F><>ȡ<EFBFBD>¶<EFBFBD><C2B6><EFBFBD><EFBFBD><EFBFBD>
+int OceanOptics_lib::GetDeviceTemperature(float &fTemperature)
+{
+	if (m_iSpectralmeterHandle == -100)
+	{
+		//printf("\nNo!!!!!!!!!!!!\n");
+		return 1;
+	}
+
+	double temp;
+	int error;
+
+	//    usleep(1000000);
+	//printf("\nGetting TEC temperature\n");
+	temp = seabreeze_read_tec_temperature(m_iSpectralmeterHandle, &error);
+	//printf("Read tec temperature result is %1.2f C [%s]\n", temp, get_error_string(error));
+
+	fTemperature = temp;
+
+	return 0;
+}
+
+//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8>Ϣ
+int OceanOptics_lib::GetDeviceInfo(DeviceInfo &Info)
+{
+	if (m_iSpectralmeterHandle == -100)
+	{
+		//printf("\nNo!!!!!!!!!!!!\n");
+		return 1;
+	}
+
+	string deviceType = GetDeviceType(m_iSpectralmeterHandle);
+	string SN = GetSerialNumber(m_iSpectralmeterHandle);
+
+	Info.strPN = deviceType;
+	Info.strSN = SN;
+
+	return 0;
+}
+
+//<2F><>ȡ<EFBFBD>豸<EFBFBD><E8B1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+int OceanOptics_lib::GetDeviceAttribute(DeviceAttribute &Attr)
+{
+	if (m_iSpectralmeterHandle == -100)
+	{
+		//printf("\nNo!!!!!!!!!!!!\n");
+		return 1;
+	}
+
+	int error;
+	int flag;
+	int spec_length;
+	double *wls = 0;
+
+	//printf("\n\nGetting formatted spectrum length.\n");
+	spec_length = seabreeze_get_formatted_spectrum_length(m_iSpectralmeterHandle, &error);
+	//printf("Get formatted spectrum length result is (%d) [%s]\n", spec_length, get_error_string(error));
+
+	Attr.iPixels = spec_length;
+	Attr.iMinIntegrationTimeInMS = 0;
+	Attr.iMaxIntegrationTimeInMS = 60000;
+
+	if (spec_length > 0) {
+		wls = (double *)calloc((size_t)spec_length, sizeof(double));
+
+		//printf("\nGetting wavelengths.\n");
+		flag = seabreeze_get_wavelengths(m_iSpectralmeterHandle, &error, wls, spec_length);
+		//printf("Get wavelengths result is (%d) [%s]\n", flag, get_error_string(error));
+		//printf("\tPixel 20 is wavelength %1.2f nm\n", wls[20]);
+
+		for (int tmp = 0; tmp < spec_length; tmp++)
+		{
+			Attr.fWaveLengthInNM[tmp] = wls[tmp];
+		}
+
+		free(wls);
+	}
+
+	return 0;
+}
+
+bool OceanOptics_lib::isSuccess(char* resultStr)
+{
+	if (strstr(resultStr, "Success") == NULL)//<2F><>a<EFBFBD>в<EFBFBD><D0B2><EFBFBD>b<EFBFBD><62><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڣ<EFBFBD>
+	{
+		cout << "not found\n";//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+		return true;
+	}
+	else//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڡ<EFBFBD>
+	{
+		cout << "found\n"; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+		return false;
+	}
+}
+const char* OceanOptics_lib::get_error_string(int error)
+{
+	static char buffer[32];
+	seabreeze_get_error_string(error, buffer, sizeof(buffer));
+	return buffer;
+}
+
+string OceanOptics_lib::GetDeviceType(int index)
+{
+	char type[16];
+	int error;
+
+	seabreeze_get_model(index, &error, type, sizeof(type));
+	//printf("...Result is (%s) [%s]\n", type, get_error_string(error));
+	type[15] = '\0';
+
+	string deviceType = type;
+
+	return deviceType;
+}
+
+string OceanOptics_lib::GetSerialNumber(int index)
+{
+	static char serial_number[32];//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>static<69><63><EFBFBD>˱<EFBFBD><CBB1><EFBFBD><EFBFBD>ᶨ<EFBFBD><E1B6A8><EFBFBD><EFBFBD>stack<63><6B><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>غ󣬾<D8BA><F3A3ACBE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	int flag;
+	int error;
+
+	//printf("\n\nGetting serial number.\n");
+	flag = seabreeze_get_serial_number(index, &error, serial_number, 32);
+	//printf("Get serial number result is (%d) [%s]\n", flag, get_error_string(error));
+	serial_number[31] = '\0';
+	if (flag > 0) {
+		//printf("\tSerial number: [%s]\n", serial_number);
+	}
+
+	string sn = serial_number;
+
+	return sn;
+}

source/OSIF/include/api/DeviceFactory.h

@@ -0,0 +1,63 @@
+/***************************************************//**
+ * @file    DeviceFactory.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * Notes:
+ *
+ * This class allows Device class instances to be created
+ * using just the name of the class as a string.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef SEABREEZE_DEVICE_FACTORY_H
+#define SEABREEZE_DEVICE_FACTORY_H
+
+#include <string>
+#include <map>
+#include "common/devices/Device.h"
+
+namespace seabreeze {
+
+    class DeviceFactory {
+
+    public:
+        static DeviceFactory* getInstance();
+        static DeviceFactory* instance;
+        static void shutdown();
+
+        Device *create(const std::string& name);
+        Device *create(int index);
+        int getNumberOfDeviceTypes();
+
+    private:
+        typedef Device *(*creatorFunction)(void);
+        DeviceFactory();
+        std::map<std::string, creatorFunction> nameToCreator;
+    };
+
+}
+
+#endif

source/OSIF/include/api/DllDecl.h

@@ -0,0 +1,56 @@
+/***************************************************//**
+ * @file    DllDecl.h
+ * @date    September 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This class provides the DLL import/export decorations
+ * required for Windows DLLs.  It is encapsulated to
+ * reduce copy-paste and to allow a single point of
+ * maintenance.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ******************************************************/
+
+#ifndef SEABREEZE_DLL_DECL_H
+#define SEABREEZE_DLL_DECL_H
+
+#ifdef _WINDOWS
+    #ifdef BUILD_DLL
+        #define DLL_DECL __declspec(dllexport)
+    #else
+        #define DLL_DECL __declspec(dllimport)
+    #endif
+
+    // "STL member 'seabreeze::api::Foo::foo' needs to have dll-interface
+    // to be used by clients of class 'seabreeze::api::Foo'"
+    #pragma warning (disable: 4251)
+
+    // "non dll-interface class 'seabreeze::Foo' used as base for dll-interface
+    // class 'seabreeze::api::Bar'"
+    #pragma warning (disable: 4275)
+#else
+    #define DLL_DECL
+#endif
+
+#endif

source/OSIF/include/api/SeaBreezeWrapper.h

@@ -0,0 +1,864 @@
+/***************************************************//**
+ * @file    SeaBreezeWrapper.h
+ * @date    July 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a trivial interface to SeaBreeze that allows
+ * the user to connect to devices over USB.
+ * This is intended as a usable and extensible API.
+ *
+ * This provides a C interface to help with linkage.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_WRAPPER_H
+#define SEABREEZE_WRAPPER_H
+
+#define SEABREEZE_API_VERSION "3.0.11"  //!< current version of the SeaBreezeWrapper API
+#define SEABREEZE_MAX_DEVICES 32        //!< how many different spectrometer types we support
+
+#include "api/DllDecl.h"
+
+#ifdef __cplusplus
+
+/**
+* @brief Encapsulates all SeaBreeze classes
+*/
+namespace seabreeze {
+	class Device;
+}
+
+/**
+    Original interface to SeaBreeze.  SeaBreezeAPI represents a proposed architecture for
+    future development.
+*/
+class DLL_DECL SeaBreezeWrapper {
+public:
+
+    //! get handle to Singleton
+    static SeaBreezeWrapper *getInstance();
+
+    //! free some static memory under Microsoft profiler
+    static void shutdown();
+
+    // lifecycle
+    int    openSpectrometer          (int index, int *errorCode);
+    int    closeSpectrometer         (int index, int *errorCode);
+
+    // metadata
+    int    getModel                  (int index, int *errorCode, char *buf, int len);
+    int    getSerialNumber           (int index, int *errorCode, char *buf, int len);
+
+    // basic acquisitions
+    void   setIntegrationTimeMicrosec(int index, int *errorCode, unsigned long integration_time_micros);
+    int    getWavelengths            (int index, int *errorCode, double *wavelengths, int length);
+    int    getFormattedSpectrum      (int index, int *errorCode, double* buffer, int buffer_length);
+    int    getUnformattedSpectrum    (int index, int *errorCode, unsigned char *buffer, int buffer_length);
+    int    getFormattedSpectrumLength(int index, int *errorCode);
+    int    getUnformattedSpectrumLength(int index, int *errorCode);
+    long   getMinIntegrationTimeMicrosec(int index, int *errorCode);
+    long   getMaxIntegrationTimeMicrosec(int index, int *errorCode);
+    int    getMaximumIntensity(int index, int *errorCode);
+
+    // advanced features
+    int    getElectricDarkPixelIndices(int index, int *errorCode, int *indices, int length);
+    void   setTriggerMode            (int index, int *errorCode, int mode);
+    void   setStrobeEnable           (int index, int *errorCode, unsigned char strobe_enable);
+    void   setShutterOpen            (int index, int *errorCode, unsigned char opened);
+    void   setContinuousStrobePeriodMicrosec(int index, int *errorCode, unsigned short strobe_id, unsigned long period_usec);
+    void   setAcquisitionDelayMicrosec(int index, int *errorCode, unsigned long delay_usec);
+
+    // Buffering features
+    void   clearBuffer               (int index, int *errorCode);
+    unsigned long getBufferElementCount(int index, int *errorCode);
+    unsigned long getBufferCapacity  (int index, int *errorCode);
+    unsigned long getBufferCapacityMaximum(int index, int *errorCode);
+    unsigned long getBufferCapacityMinimum(int index, int *errorCode);
+    void   setBufferCapacity         (int index, int *errorCode, unsigned long capacity);
+
+    // EEPROM access
+    int    readEEPROMSlot            (int index, int *errorCode, int slot_number, unsigned char *buffer, int buffer_length);
+    int    writeEEPROMSlot           (int index, int *errorCode, int slot_number, unsigned char *buffer, int buffer_length);
+
+    // irradiance calibration
+    int    readIrradCalibration      (int index, int *errorCode, float *buffer, int buffer_length);
+    int    writeIrradCalibration     (int index, int *errorCode, float *buffer, int buffer_length);
+    int    hasIrradCollectionArea    (int index, int *errorCode);
+    float  readIrradCollectionArea   (int index, int *errorCode);
+    void   writeIrradCollectionArea  (int index, int *errorCode, float area);
+
+    // thermal-electric cooler
+    double readTECTemperature        (int index, int *errorCode);
+    void   setTECTemperature         (int index, int *errorCode, double temperature_degrees_celsius);
+    void   setTECEnable              (int index, int *errorCode, unsigned char tec_enable);
+    void   setTECFanEnable           (int index, int *errorCode, unsigned char tec_fan_enable);
+
+    // Wrapper features
+    void   setVerbose                (bool flag);
+    void   setLogfile                (char *path, int length);
+    int    getAPIVersionString       (char *buffer, int length);
+    int    getErrorString            (int errorCode, char *buffer, int buffer_length);
+
+    // raw USB access
+    int    writeUSB                  (int index, int *errorCode, unsigned char endpoint, unsigned char *buffer, unsigned int length);
+    int    readUSB                   (int index, int *errorCode, unsigned char endpoint, unsigned char *buffer, unsigned int length);
+    int    getUSBDescriptorString    (int index, int *errorCode, int id, unsigned char *buffer, int length);
+
+    // light sources (JAZ?)
+    int    getLightSourceCount       (int index, int *errorCode);
+    void   setLightSourceEnable      (int index, int *errorCode, int lightIndex, unsigned char enable);
+    void   setLightSourceIntensity   (int index, int *errorCode, int lightIndex, double intensity);
+
+private:
+    SeaBreezeWrapper();
+    virtual ~SeaBreezeWrapper();
+
+    //! Singleton
+    static SeaBreezeWrapper *instance;
+
+    //! types of supported Ocean Optics devices (not actual devices found enumerated on the USB bus)
+    seabreeze::Device *devices[SEABREEZE_MAX_DEVICES];
+};
+
+extern "C" {
+#endif /* __cplusplus */
+
+    /* All of these C functions start with seabreeze_ to prevent namespace
+     * collisions.
+     */
+
+    /**
+     * @brief This function opens a device attached to the system.
+     * @param index (Input) The index of a USB device to try to open.
+     *        Valid values will range from 0 to N-1 for N connected devices.
+     * @param error_code (Output) A pointer to an integer that can be used
+     *        for storing error codes.
+     * @return int: The function will return an integer of 0 if it opened a
+     *      device successfully, or 1 if no device was opened (in which
+     *      case the error_code variable will be set).
+     *
+     * This can be called repeatedly with incrementing index values (until
+     * it returns 1) to open all connected devices.
+     *
+     * Note that the index used to open a device with this function should also
+     * be used to communicate with that same device in the other functions
+     * provided here.
+     */
+    DLL_DECL int
+    seabreeze_open_spectrometer(int index, int *error_code);
+
+    /**
+     * @brief This function closes the spectrometer attached to the system.
+     * @param index (Input) The index of a device previously opened with
+     *        open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used
+     *        for storing error codes.
+     * @return int: This function will return 1 no matter what!  (MZ)
+     */
+    DLL_DECL int
+    seabreeze_close_spectrometer(int index, int *error_code);
+
+    /**
+     * @brief This function returns a description of the error denoted by
+     *        error_code.
+     * @param error_code (Input) The integer error code to look up.  Error
+     *        codes not be zero, but can be any non-zero integer (positive or
+     *        negative).
+     * @param buffer (Output) A character buffer allocated to contain at least
+     *        'buffer_length' bytes, which will be populated with the string
+     *        description of the given error code.
+     * @param buffer_length (Input) allocated size of the output buffer
+     * @return int: Number of bytes written to buffer.
+     */
+    DLL_DECL int
+    seabreeze_get_error_string(int error_code, char *buffer, int buffer_length);
+
+    /**
+     * @brief This function returns a string denoting the type of the device.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *      error codes.  This may be NULL.
+     * @param buffer (Output)  A character buffer allocated to contain at least
+     *      'buffer_length' bytes, which will be populated with the
+     *      spectrometer type.
+     * @param buffer_length (Input) allocated size of the buffer
+     * @return int: Number of bytes written to the buffer.
+     *
+     * The populated buffer will hold one of the following strings:
+     *
+     * \verbatim
+     *      NONE:        Used if no spectrometer is found (error_code will also be set)
+     *      HR2000:      Represents an HR2000 Spectrometer
+     *      HR2000PLUS:  Represents an HR2000+ Spectrometer
+     *      HR4000:      Represents an HR4000 Spectrometer
+     *      JAZ:         Represents a Jaz Spectrometer
+     *      MAYA2000:    Represents a Maya2000 Spectrometer
+     *      MAYALSL:     Represents a Maya-LSL Spectrometer
+     *      MAYA2000PRO: Represents a Maya2000 Pro Spectrometer
+     *      NIRQUEST256: Represents an NIRQuest256 Spectrometer
+     *      NIRQUEST512: Represents an NIRQuest512 Spectrometer
+     *      QE65000:     Represents a QE65000 Spectrometer
+     *      QE-PRO:      Represents a QE-Pro Spectrometer
+     *      STS:         Represents an STS Spectrometer
+     *      TORUS:       Represents a Torus Spectrometer
+     *      USB2000:     Represents a USB2000 Spectrometer
+     *      USB2000PLUS: Represents a USB2000+ Spectrometer
+     *      USB4000:     Represents a USB4000 Spectrometer
+     * \endverbatim
+     */
+    DLL_DECL int
+    seabreeze_get_model(int index, int *error_code, char *buffer, int buffer_length);
+
+    /**
+     * @brief This function sets the trigger mode for the specified device.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *      error codes.
+     * @param mode (Input) a trigger mode (0 = normal, 1 = software, 2 = synchronization,
+     *        3 = external hardware, etc.)
+     *
+     * Note that requesting an unsupported mode will result in an error.
+     */
+
+    DLL_DECL void
+    seabreeze_set_trigger_mode(int index, int *error_code, int mode);
+
+    /**
+     * @brief This function sets the integration time for the specified device.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *      error codes.
+     * @param integration_time_micros (Input) The new integration time in units of
+     *      microseconds
+     *
+     * This function does not automatically perform a stability scan.
+     * If your application requires a stability scan following a change
+     * in integration time, you need to command that yourself.
+     */
+    DLL_DECL void
+    seabreeze_set_integration_time_microsec(int index, int *error_code,
+            unsigned long integration_time_micros);
+
+    /**
+     * @brief This function returns the smallest integration time setting,
+     *        in microseconds, that is valid for the spectrometer.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @return Returns minimum legal integration time in microseconds if > 0.
+     *        On error, returns -1 and error_code will be set accordingly.
+     */
+    DLL_DECL long
+    seabreeze_get_min_integration_time_microsec(int index, int *error_code);
+
+    /**
+     * @brief This function sets the shutter state on the spectrometer.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param opened (Input) A logical boolean used for denoting the desired
+     *      state (opened/closed) of the shutter.   If the value of opened is
+     *      non-zero, then the shutter will open.  If the value of opened is
+     *      zero, then the shutter will close.
+     */
+    DLL_DECL void
+    seabreeze_set_shutter_open(int index, int *error_code, unsigned char opened);
+
+    /**
+     * @brief This function sets the strobe enable on the spectrometer.  Note that
+     *        this refers to a particular set of one or more digital pins on the
+     *        device: lamp enable, single strobe, and continuous strobe may all
+     *        be affected by this setting, and these generally control lamps
+     *        that are external to the device.  Note that this is related to, but
+     *        different from, the light source interface which allows the intensity
+     *        and/or enable status of individual light sources (e.g. lamp bulbs,
+     *        LEDs, or lasers) in attached modules to be controlled.  Refer to
+     *        the seabreeze_xxx_light_source_ functions for finer control of
+     *        certain light source modules that are more closely integrated with
+     *        the spectrometer.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output)  A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param strobe_enable (Input) A logical boolean used for denoting the
+     *      desired value (high/low) of the strobe-enable pin.   If the value of
+     *      strobe_enable is zero, then the pin should be set low.  If the value
+     *      of strobe_enable is non-zero, then the pin should be set high.
+     */
+    DLL_DECL void
+    seabreeze_set_strobe_enable(int index, int *error_code, unsigned char strobe_enable);
+
+    /**
+     * @brief This function gets the number of attached light sources that can
+     *        be programmatically controlled.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output)  A pointer to an integer that can be used for storing
+     *        error codes.
+     * @return The number of light sources that can be controlled
+     */
+    DLL_DECL int
+    seabreeze_get_light_source_count(int index, int *error_code);
+
+    /**
+     * @brief This function sets the enable status on a connected light source.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output)  A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param light_index (Input)  The index of the light source.  This will
+     *      usually be zero, but if the light module contains multiple LEDs,
+     *      bulbs, lasers, etc. then this may be higher.  Use
+     *      seabreeze_get_light_source_count() to bound the maximum value .
+     * @param enable (Input) A logical boolean used for denoting whether to enable
+     *      the indicated light source.   If the value of
+     *      enable is zero, then the light source should be disabled.  If the value
+     *      of enable is non-zero, then the light source should be enabled.
+     */
+    DLL_DECL void
+    seabreeze_set_light_source_enable(int index, int *error_code,
+            int light_index, unsigned char enable);
+
+    /**
+     * @brief This function sets the intensity of a connected light source.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output)  A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param light_index (Input)  The index of the light source.  This will
+     *      usually be zero, but if the light module contains multiple LEDs,
+     *      bulbs, lasers, etc. then this may be higher.  Use
+     *      seabreeze_get_light_source_count() to bound the maximum value.
+     * @param intensity (Input) The desired intensity of the light source.  The
+     *      range of intensities is normalized over [0, 1], where 0 is the
+     *      minimum controllable intensity of the light source, and 1 is the
+     *      maximum.
+     *
+     * @warning SETTING THE INTENSITY TO ZERO MAY NOT CAUSE THE LIGHT SOURCE
+     *      TO TURN OFF COMPLETELY.  The light source will go to the
+     *      dimmest level it can reach without changing its enable status.
+     *      To switch the light source off, try using the
+     *      seabreeze_set_light_source_enable() function or provide the
+     *      operator with another way to disable or block the light source.
+     */
+    DLL_DECL void
+    seabreeze_set_light_source_intensity(int index, int *error_code,
+            int light_index, double intensity);
+
+    /**
+     * @brief This function reads a string out of the spectrometer's EEPROM slot
+     *        and returns the result.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param slot_number (Input) The number of the slot to read out.  Possible
+     *        values are 0 through 16*.
+     * @param buffer (Output)  A buffer (with memory already allocated) to hold the
+     *        value read out of the EEPROM slot
+     * @param buffer_length (Input) The length of the allocated output buffer (typically 16)
+     * @return int: The number of bytes read from the EEPROM slot into the buffer
+     *
+     * (*) Actual maximum slot count varies by spectrometer model.  For the number of supported
+     *     slots on your spectrometer, see EEPROMSlotFeature instantiation in appropriate
+     *     device file under src/vendors/OceanOptics/devices.
+     */
+    DLL_DECL int
+    seabreeze_read_eeprom_slot(int index, int *error_code, int slot_number, unsigned char *buffer,
+            int buffer_length);
+
+    /**
+     * @brief This function writes a string to a spectrometer's EEPROM slot
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer for storing error codes.
+     * @param slot_number (Input) The number of the slot being written (e.g. 0-16*).
+     * @param buffer (Input) A buffer containing the text to write to the slot.
+     * @param buffer_length (Input) The length of the text to write (typically 15)
+     * @return number of bytes written
+     *
+     * @warning CARELESS USE OF THIS FUNCTION CAN RENDER YOUR SPECTROMETER INOPERABLE,
+     *          POSSIBLY REQUIRING R.M.A. OR REFLASHING TO RESTORE FUNCTIONALITY.
+     *          PLEASE READ YOUR SPECTROMETER'S DATA SHEET CAREFULLY BEFORE USE.
+     *
+     * (*) See note in seabreeze_read_eeprom_slot() regarding per-device slot limits.
+     */
+    DLL_DECL int
+    seabreeze_write_eeprom_slot(int index, int *error_code, int slot_number, unsigned char *buffer,
+            int buffer_length);
+
+    /**
+     * @brief This function reads out an irradiance calibration from the spectrometer's
+     *        internal memory if that feature is supported.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param buffer (Output) array of floating point values into which calibration values are stored
+     * @param buffer_length (Input) maximum number of values to copy from the device into buffer
+     * @return int: the number of floats read from the device into the buffer
+     */
+    DLL_DECL int
+    seabreeze_read_irrad_calibration(int index, int *error_code, float *buffer,
+        int buffer_length);
+
+    /**
+     * @brief This function writes an irradiance calibration to the spectrometer's
+     *        internal memory if that feature is supported.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param buffer (Output) array of floating point values to store into the device
+     * @param buffer_length (Input) number of calibration factors to write
+     * @return int: the number of floats written from the buffer to the device
+     */
+    DLL_DECL int
+    seabreeze_write_irrad_calibration(int index, int *error_code, float *buffer,
+        int buffer_length);
+
+    /**
+     * @brief This function checks for an irradiance collection area in the spectrometer's
+     *        internal memory if that feature is supported.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @return int: 0 if no collection area available, 1 if available.
+     */
+    DLL_DECL int
+    seabreeze_has_irrad_collection_area(int index, int *error_code);
+
+    /**
+     * @brief This function reads an irradiance collection area from the spectrometer's
+     *        internal memory if that feature is supported.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @return float: collection area (typically in units of cm^2) read from device
+     */
+    DLL_DECL float
+    seabreeze_read_irrad_collection_area(int index, int *error_code);
+
+    /**
+     * @brief This function writes an irradiance collection area to the spectrometer's
+     *        internal memory if that feature is supported.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param area (Input) collection area to save to the EEPROM (presumably cm^2)
+     */
+    DLL_DECL void
+    seabreeze_write_irrad_collection_area(int index, int *error_code, float area);
+
+    /**
+     * @brief This function reads the value of the TEC and returns the value in
+     *        degrees celsius.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @return int: The TEC temperature in degrees Celsius.
+     */
+    DLL_DECL double
+    seabreeze_read_tec_temperature(int index, int *error_code);
+
+    /**
+     * @brief This function sets the TEC temperature.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param temperature_degrees_celsius (Input) The desired temperature, in degrees
+     *        Celsius.
+     */
+    DLL_DECL void
+    seabreeze_set_tec_temperature(int index, int *error_code,
+            double temperature_degrees_celsius);
+
+    /**
+     * @brief This function enables the TEC feature on the spectrometer.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param tec_enable (Input) A logical boolean that denotes the desired TEC enable
+     *        state.  If the value of tec_enable is zero, the TEC should be disabled.
+     *        If the value of tec_enable is non-zero, the TEC should be enabled.
+     */
+    DLL_DECL void
+    seabreeze_set_tec_enable(int index, int *error_code, unsigned char tec_enable);
+
+    /**
+     * @brief This function enables the TEC Fan on the spectrometer.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param tec_fan_enable (Input) A logical boolean that denotes the desired TEC fan enable
+     *        state.  If the value of tec_fan_enable is zero, the TEC fan should be disabled.
+     *        If the value of tec_fan_enable is non-zero, the TEC fan should be enabled.
+     */
+    DLL_DECL void
+    seabreeze_set_tec_fan_enable(int index, int *error_code, unsigned char tec_fan_enable);
+
+    /**
+     * @brief This acquires a spectrum and returns the answer in raw, unformatted bytes.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param buffer (Output) A buffer (with memory already allocated) to hold the
+     *        spectral data
+     * @param buffer_length (Input) The length of the buffer in bytes (not pixels)
+     * @return int: The number of bytes read into the buffer
+     * @see   sample-code/c/demo-unformatted-spectrum.c
+     *
+     * An unformatted spectrum is the raw sequence of bytes returned by the spectrometer to 
+     * the PC over USB.  The bytes have not been broken down into pixels, they're in the 
+     * original endianness, absolutely nothing has been done to them.  The caller is expected 
+     * to know how many bytes are returned by each spectrometer model, which bytes indicate 
+     * synchronization points or whatever, etc.  
+     */
+    DLL_DECL int
+    seabreeze_get_unformatted_spectrum(int index, int *error_code,
+            unsigned char *buffer, int buffer_length);
+
+    /**
+     * @brief This acquires a spectrum and returns the answer in formatted
+     *        floats.  In this mode, auto-nulling should be automatically
+     *        performed for devices that support it.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param buffer (Output) A buffer (with memory already allocated) to hold the
+     *        spectral data
+     * @param buffer_length (Input) The length of the buffer in floats (not bytes)
+     * @return int: The number of floats read into the buffer
+     *
+     * A formatted spectrum returns exactly one double-precision floating-point IEEE value 
+     * per pixel, as opposed to a raw byte stream.  It has also had autonulling (gain control) 
+     * applied, meaning it has been scaled up to the spectrometer's full dynamic range using 
+     * the gain setting recorded in that spectrometer’s EEPROM.
+     */
+    DLL_DECL int
+    seabreeze_get_formatted_spectrum(int index, int *error_code,
+            double* buffer, int buffer_length);
+
+    /**
+     * @brief This returns an integer denoting the length of a raw spectrum
+     *        (as returned by get_unformatted_spectrum(...)).
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *      error codes.
+     * @return int: An integer denoting the length of an unformatted spectrum in bytes
+     *
+     * The caller is expected to know the number of bytes per pixel and the endian
+     * ordering, but it will normally be 2 bytes per pixel, LSB-MSB order.
+     */
+    DLL_DECL int
+    seabreeze_get_unformatted_spectrum_length(int index, int *error_code);
+
+    /**
+     * @brief This returns an integer denoting the number of pixels in a
+     *        formatted spectrum (as returned by get_formatted_spectrum(...)).
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @return int: An integer denoting the length of a formatted spectrum (in pixels)
+     */
+    DLL_DECL int
+    seabreeze_get_formatted_spectrum_length(int index, int *error_code);
+
+    /**
+     * @brief This computes the wavelengths for the spectrometer and fills in the
+     *        provided array (up to the given length) with those values.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param wavelengths (Output) A pre-allocated array of doubles into which the
+     *        wavelengths will be copied
+     * @param length (Input) The number of values to copy into the wavelength array (this should
+     *        be no larger than the number of doubles allocated in the wavelengths
+     *        array)
+     * @return int: An integer denoting the number of wavelengths written to the buffer
+     */
+    DLL_DECL int
+    seabreeze_get_wavelengths(int index, int *error_code, double *wavelengths, int length);
+
+    /**
+     * @brief This reads the device's serial number and fills the
+     *        provided array (up to the given length) with it.
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param buffer (Output) A pre-allocated array of characters into which the serial number
+     *        will be copied
+     * @param buffer_length (Input) The number of values to copy into the buffer (this should
+     *        be no larger than the number of chars allocated in the buffer) (typically 16)
+     * @return int: An integer denoting the number of bytes written into the buffer
+     *
+     * Note that "serial numbers" may include both digits and letters
+     */
+    DLL_DECL int
+    seabreeze_get_serial_number(int index, int *error_code, char *buffer, int buffer_length);
+
+    /**
+     * @brief This fills in the provided array (up to the given length) with the indices
+     *        of the pixels that are electrically active but optically masked
+     *        (a.k.a. electric dark pixels).
+     * @param index (Input) The index of a device previously opened with open_spectrometer().
+     * @param error_code (Output) A pointer to an integer that can be used for storing
+     *        error codes.
+     * @param indices (Output) A pre-allocated array of ints into which the pixel indices
+     *        will be copied
+     * @param length (Input) The number of values to copy into the indices array (this should
+     *        be no larger than the number of ints allocated in the indices array)
+     * @return int: An integer denoting the number of indices written into the indices buffer
+     *
+     * Note that not all detectors have optically masked pixels; in that case,
+     * this function will return zero.
+     */
+    DLL_DECL int
+    seabreeze_get_electric_dark_pixel_indices(int index, int *error_code,
+        int *indices, int length);
+
+    /**
+     * @brief Shutdown SeaBreeze completely, releasing all resources and destroying
+     *        any cached device handles.
+     *
+     * This function is not normally needed (Singletons are destroyed automatically
+     * at process end), but calling this explicitly can resolve some spurious warnings
+     * in highly paranoid memory leak profilers.
+     */
+    DLL_DECL void
+    seabreeze_shutdown();
+
+    /**
+    * @brief Write a raw array of bytes to a USB spectrometer.
+    * @param index (Input) index of an opened spectrometer
+    * @param errorCode (Output) pointer to an allocated integer field for receiving error codes
+    * @param endpoint (Input) USB endpoint for write operation
+    *        (see src/vendors/OceanOptics/features/raw_bus_access/RawUSBBusAccessFeature.cpp)
+    * @param buffer (Input) array of bytes to send to USB spectrometer
+    * @param length (Input) number of bytes to write from buffer to spectrometer
+    * @return number of bytes written
+    *
+    * Write the bytes in the buffer according to the two command bytes at the
+    * start of the buffer.
+    *
+    * \section Endpoints
+    *
+    * You may wonder why the caller needs to specify an explicit endpoint for
+    * raw read and write operations; does not SeaBreeze already know the appro-
+    * priate endpoints for any open spectrometer, for example.  Yes it does,
+    * but currently there is no easy way to extract endpoints from a generic
+    * spectrometer, due to the fact that OOIUSBCypressEndpointMap and
+    * OOIUSBSTSEndpointMap do not share a common base class (see
+    * OOIUSBEndpointMaps.h).
+    *
+    * We could attempt to extract them from the TransferHelpers held by
+    * OOIUSBInterface, but without a Hint to use as a key, we would likely
+    * obtain unmatched or inappropriate versions for control exchanges.
+    * As ControlHint and OBPControlHint share no common ancestor or type data
+    * to associate them while distinguishing from other hint types, we cannot
+    * automatically infer appropriate control endpoints.
+    *
+    * And finally, we have no way of knowing that the user really wants to
+    * use control endpoints anyway: they may actually desire high-speed
+    * spectral retrieval.  So really, this needs to remain a manual external
+    * operation until such time as we provide a much richer, generic query
+    * interface over our internal endpoint lookup tables.
+    *
+    * \section Example
+    *
+    * For instance, for most USB spectrometers, the hex values <tt>05 00</tt> in
+    * the buffer means 'read EEPROM slot 0'. Writing this command, and following
+    * it with the \c seabreeze_read_usb command and the same hex <tt>05 00</tt>
+    * in the buffer, will result in the spectrometer's serial number, in ASCII
+    * characters, being delivered to the subsequent bytes in the buffer array.
+    * This would appear in the output buffer as:
+    *
+    * \code
+    *   05 00 55 53 42 32 2B 48 30 31 34 31 36 00 00 00 00 (hex)
+    * \endcode
+    *
+    * (<tt>USB2+H01416</tt> ASCII, skipping the two command bytes)
+    *
+    * A C or C++ program could use the data as-is, but a C# program could
+    * append to a string, each byte, cast as char, stopping on the first null
+    * character:
+    *
+    * \code
+    *   string serial = "";
+    *   for (int i = 0; i < length && buffer[i] != '\0'; i++)
+    *     serial += (char)buffer[i];
+    * \endcode
+    *
+    * This is equivalent to:
+    *
+    * \code
+    *   string serial = System.Text.ASCIIEncoding.ASCII.GetString(buffer).Trim('\0');
+    * \endcode
+    *
+    * For C# and VB.NET, the trailing zero-fill must be removed. Those null
+    * characters would not print or display on a screen but would make a file
+    * name invalid.
+    */
+    DLL_DECL int
+    seabreeze_write_usb(int index, int *errorCode, unsigned char endpoint, unsigned char* buffer, unsigned int length);
+
+    /**
+    * @brief Read a raw array of bytes from a USB spectrometer.
+    * @param index (Input) index of a previously opened spectrometer
+    * @param errorCode (Output) pointer to an allocated integer field for receiving error codes
+    * @param endpoint (Input) USB endpoint for read operation
+    *        (see src/vendors/OceanOptics/features/raw_bus_access/RawUSBBusAccessFeature.cpp)
+    * @param buffer (Input) array of allocated bytes at which to recieve USB data
+    * @param length (Input) maximum number of bytes to read from spectrometer
+    * @return number of received bytes written to buffer
+    *
+    * Read bytes from the spectrometer into the buffer. The buffer starts with
+    * two bytes of command information that will be followed by the transferred
+    * bytes. The read and write USB functions allow low-level control of the
+    * spectrometer via USB commands. The higher-level SeaBreeze functions issue
+    * USB commands internally.
+    *
+    * Reading USB data takes two steps. First a seabreeze_write_usb call requests
+    * the transfer, then a seabreeze_read_usb call delivers the data. Writing a buffer
+    * to USB takes one step. The operating system handle for the spectrometer is
+    * managed by SeaBreeze. USB has a concept of "end points". These are implicitly
+    * addressed by the seabreeze_read_usb and seabreeze_write_usb functions.
+    */
+    DLL_DECL int
+    seabreeze_read_usb(int index, int *errorCode, unsigned char endpoint, unsigned char* buffer, unsigned int length);
+
+    /**
+    * @brief Get the SeaBreeze library's internal version identifier.
+    * @param buffer (Output) pointer to an allocated character array
+    *                        to hold the returned version string
+    * @param len    (Input)  size of the allocated buffer
+    * @return number of bytes written to buffer
+    */
+    DLL_DECL int
+    seabreeze_get_api_version_string(char *buffer, int len);
+
+    /**
+    * @brief Get a USB descriptor string by number
+    * @param index     (Input)  Which spectrometer to set
+    * @param errorCode (Output) pointer to allocated integer to receive error code
+    * @param id        (Input)  numeric ID of the desired USB descriptor string
+    * @param buffer    (Output) pointer to an allocated character array to hold
+    *                           the returned descriptor string
+    * @param len       (Input)  size of the allocated buffer
+    * @return number of bytes written to buffer
+    */
+    DLL_DECL int
+    seabreeze_get_usb_descriptor_string(int index, int *errorCode, int id, unsigned char *buffer, int len);
+
+    /**
+    * @brief Set the continuous strobe period in microseconds
+    * @param index (Input) Which spectrometer to set
+    * @param errorCode (Output) pointer to allocated integer to receive error code
+    * @param strobe_id (Input) index of the strobe generator (currently always zero)
+    * @param period_usec (Input) total period of the strobe, in microseconds
+    * @return zero (on success or failure; check errorCode)
+    *
+    * The resolution is 0.1 milliseconds (100 microseconds).
+    */
+    DLL_DECL void
+    seabreeze_set_continuous_strobe_period_microsec(int index, int *errorCode,
+        unsigned short strobe_id, unsigned long period_usec);
+
+    /**
+    * @brief Set the acquisition delay (trigger delay) in microseconds.  This
+    *        controls the amount of time between a particular event
+    *        (usually a request for spectrum or an external trigger pulse)
+    *        and the start of acquisition.
+    */
+    DLL_DECL void
+    seabreeze_set_acquisition_delay_microsec(int index,
+        int *errorCode, unsigned long delay_usec);
+
+    /**
+    * @brief Clear the spectrum buffer (if equipped)
+    * @param index (Input) Which spectrometer should have its buffer cleared
+    * @param error_code (Output) Pointer to allocated integer to receive error code
+    */
+    DLL_DECL void
+    seabreeze_clear_buffer(int index, int *error_code);
+
+    /**
+    * @brief Get the number of spectra presently in the buffer (if equipped)
+    * @param index (Input) Which spectrometer should have its buffer queried
+    * @param error_code (Output) Pointer to allocated integer to receive error code
+    * @return Number of spectra in the buffer
+    */
+    DLL_DECL unsigned long
+    seabreeze_get_buffer_element_count(int index, int *error_code);
+
+    /**
+    * @brief Get the currently configured size of the data buffer (if equipped)
+    * @param index (Input) Which spectrometer should have its buffer queried
+    * @param error_code (Output) Pointer to allocated integer to receive error code
+    * @return The present limit on the number of spectra that will be retained.
+    */
+    DLL_DECL unsigned long
+    seabreeze_get_buffer_capacity(int index, int *error_code);
+
+    /**
+    * @brief Get the maximum possible configurable size for the data buffer (if equipped)
+    * @param index (Input) Which spectrometer should have its buffer queried
+    * @param error_code (Output) Pointer to allocated integer to receive error code
+    * @return Maximum allowed value for the buffer size
+    */
+    DLL_DECL unsigned long
+    seabreeze_get_buffer_capacity_maximum(int index, int *error_code);
+
+    /**
+    * @brief Get the minimum possible configurable size for the data buffer (if equipped)
+    * @param index (Input) Which spectrometer should have its buffer queried
+    * @param error_code (Output) Pointer to allocated integer to receive error code
+    * @return Minimum allowed value for the buffer size
+    */
+    DLL_DECL unsigned long
+    seabreeze_get_buffer_capacity_minimum(int index, int *error_code);
+
+    /**
+    * @brief Set the number of spectra that the buffer should keep
+    * @param index (Input) Which spectrometer should have its buffer modified
+    * @param error_code (Output) Pointer to allocated integer to receive error code
+    * @param capacity (Input) Limit on number of spectra to store.
+    *        Note that this must be within the range defined by the capacity minimum
+    *        and maximum values.
+    */
+    DLL_DECL void
+    seabreeze_set_buffer_capacity(int index, int *error_code, unsigned long capacity);
+
+    /**
+    * @brief Programmatically enable debug outputs to stderr
+    * @param flag (Input) zero to disable (default), non-zero to enable
+    */
+    DLL_DECL void
+    seabreeze_set_verbose(int flag);
+
+    /**
+    * @brief redirect verbose logging to named file
+    * @param flag (Input) NULL for default behavior (stderr), non-null for valid OS path
+    */
+    DLL_DECL void
+    seabreeze_set_logfile(char* pathname, int len);
+
+#ifdef __cplusplus
+};
+#endif /* __cplusplus */
+
+#endif /* SEABREEZE_WRAPPER_H */

source/OSIF/include/api/seabreezeapi/AcquisitionDelayFeatureAdapter.h

@@ -0,0 +1,63 @@
+/***************************************************//**
+ * @file    AcquisitionDelayFeatureAdapter.h
+ * @date    November 2015
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows access to SeaBreeze
+ * DataBufferFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2015, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_ACQUISITION_DELAY_FEATURE_ADAPTER_H
+#define SEABREEZE_ACQUISITION_DELAY_FEATURE_ADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/acquisition_delay/AcquisitionDelayFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class AcquisitionDelayFeatureAdapter
+                : public FeatureAdapterTemplate<AcquisitionDelayFeatureInterface> {
+        public:
+            AcquisitionDelayFeatureAdapter(AcquisitionDelayFeatureInterface *intf,
+                const FeatureFamily &f, Protocol *p, Bus *b,
+                unsigned short instanceIndex);
+
+            virtual ~AcquisitionDelayFeatureAdapter();
+
+            /* Acquisition delay functions */
+            unsigned long getAcquisitionDelayIncrementMicroseconds(int *errorCode);
+            unsigned long getAcquisitionDelayMaximumMicroseconds(int *errorCode);
+            unsigned long getAcquisitionDelayMinimumMicroseconds(int *errorCode);
+            unsigned long getAcquisitionDelayMicroseconds(int *errorCode);
+            void setAcquisitionDelayMicroseconds(int *errorCode, const unsigned long delay_usec);
+        };
+
+    } /* end namespace api */
+} /* end namespace seabreeze */
+
+#endif /* SEABREEZE_ACQUISITION_DELAY_FEATURE_ADAPTER_H */
+

source/OSIF/include/api/seabreezeapi/ContinuousStrobeFeatureAdapter.h

@@ -0,0 +1,56 @@
+/***************************************************//**
+ * @file    ContinuousStrobeFeatureAdapter.h
+ * @date    October 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows access to SeaBreeze
+ * ContinuousStrobeFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_CONTINUOUS_STROBE_FEATURE_ADAPTER_H
+#define SEABREEZE_CONTINUOUS_STROBE_FEATURE_ADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/continuous_strobe/ContinuousStrobeFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class ContinuousStrobeFeatureAdapter
+                : public FeatureAdapterTemplate<ContinuousStrobeFeatureInterface> {
+        public:
+            ContinuousStrobeFeatureAdapter(ContinuousStrobeFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~ContinuousStrobeFeatureAdapter();
+
+            void setContinuousStrobePeriodMicroseconds(int *errorCode, unsigned long period_usec);
+            void setContinuousStrobeEnable(int *errorCode, bool enable);
+        };
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/DataBufferFeatureAdapter.h

@@ -0,0 +1,63 @@
+/***************************************************//**
+ * @file    DataBufferFeatureAdapter.h
+ * @date    October 2015
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows access to SeaBreeze
+ * DataBufferFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2015, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_DATA_BUFFER_FEATURE_ADAPTER_H
+#define SEABREEZE_DATA_BUFFER_FEATURE_ADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/data_buffer/DataBufferFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class DataBufferFeatureAdapter
+                : public FeatureAdapterTemplate<DataBufferFeatureInterface> {
+        public:
+            DataBufferFeatureAdapter(DataBufferFeatureInterface *intf,
+                const FeatureFamily &f,
+                Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~DataBufferFeatureAdapter();
+
+            /* Data buffer functions */
+            void clearBuffer(int *errorCode);
+            unsigned long getNumberOfElements(int *errorCode);
+            unsigned long getBufferCapacity(int *errorCode);
+            unsigned long getBufferCapacityMaximum(int *errorCode);
+            unsigned long getBufferCapacityMinimum(int *errorCode);
+            void setBufferCapacity(int *errorCode, unsigned long capacity);
+        };
+
+    } /* end namespace api */
+} /* end namespace seabreeze */
+
+#endif /* SEABREEZE_DATA_BUFFER_FEATURE_ADAPTER_H */
+

source/OSIF/include/api/seabreezeapi/DeviceAdapter.h

@@ -0,0 +1,308 @@
+/***************************************************//**
+ * @file    DeviceAdapter.h
+ * @date    January 2015
+ * @author  Ocean Optics, Inc., Kirk Clendinning, Heliospectra
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze Device instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+#ifndef DEVICEADAPTER_H
+#define DEVICEADAPTER_H
+
+/* Includes */
+#include "common/devices/Device.h"
+#include "common/buses/DeviceLocatorInterface.h"
+#include "api/seabreezeapi/EEPROMFeatureAdapter.h"
+#include "api/seabreezeapi/IrradCalFeatureAdapter.h"
+#include "api/seabreezeapi/RawUSBBusAccessFeatureAdapter.h"
+#include "api/seabreezeapi/NonlinearityCoeffsFeatureAdapter.h"
+#include "api/seabreezeapi/TemperatureFeatureAdapter.h"
+#include "api/seabreezeapi/RevisionFeatureAdapter.h"
+#include "api/seabreezeapi/OpticalBenchFeatureAdapter.h"
+#include "api/seabreezeapi/SpectrumProcessingFeatureAdapter.h"
+#include "api/seabreezeapi/SerialNumberFeatureAdapter.h"
+#include "api/seabreezeapi/ShutterFeatureAdapter.h"
+#include "api/seabreezeapi/SpectrometerFeatureAdapter.h"
+#include "api/seabreezeapi/StrayLightCoeffsFeatureAdapter.h"
+#include "api/seabreezeapi/StrobeLampFeatureAdapter.h"
+#include "api/seabreezeapi/ContinuousStrobeFeatureAdapter.h"
+#include "api/seabreezeapi/ThermoElectricCoolerFeatureAdapter.h"
+#include "api/seabreezeapi/LightSourceFeatureAdapter.h"
+#include "api/seabreezeapi/PixelBinningFeatureAdapter.h"
+#include "api/seabreezeapi/DataBufferFeatureAdapter.h"
+#include "api/seabreezeapi/AcquisitionDelayFeatureAdapter.h"
+#include <vector>
+
+namespace seabreeze {
+    namespace api {
+
+        class DeviceAdapter {
+        public:
+            DeviceAdapter(Device *dev, unsigned long id);
+            ~DeviceAdapter();
+
+            int open(int *errorCode);
+            void close();
+
+            DeviceLocatorInterface *getLocation();
+
+            /* An for weak association to this object */
+            unsigned long getID();
+
+            /* Get a string that describes the type of device */
+            int getDeviceType(int *errorCode, char *buffer, unsigned int maxLength);
+            
+            /* Get a usb endpoint for the device according to the enumerator */
+            /*  endpointType. A 0 is returned if the endpoint requested is not in use. */
+            unsigned char getDeviceEndpoint(int *errorCode, usbEndpointType anEndpointType);
+
+            /* Get one or more raw USB access features */
+            int getNumberOfRawUSBBusAccessFeatures();
+            int getRawUSBBusAccessFeatures(long *buffer, int maxFeatures);
+            int rawUSBBusAccessRead(long featureID,
+                    int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char endpoint);
+            int rawUSBBusAccessWrite(long featureID,
+                    int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char endpoint);
+                    
+            /* Get one or more serial number features */
+            int getNumberOfSerialNumberFeatures();
+            int getSerialNumberFeatures(long *buffer, int maxFeatures);
+            int getSerialNumber(long featureID, int *errorCode,
+                    char *buffer, int bufferLength);
+            unsigned char getSerialNumberMaximumLength(long featureID, int *errorCode);
+
+            /* Get one or more spectrometer acquisition features */
+            int getNumberOfSpectrometerFeatures();
+            int getSpectrometerFeatures(long *buffer, int maxFeatures);
+            void spectrometerSetTriggerMode(long spectrometerFeatureID, int *errorCode, int mode);
+            void spectrometerSetIntegrationTimeMicros(long spectrometerFeatureID, int *errorCode,
+                    unsigned long integrationTimeMicros);
+            unsigned long spectrometerGetMinimumIntegrationTimeMicros(
+                    long spectrometerFeatureID, int *errorCode);
+            unsigned long spectrometerGetMaximumIntegrationTimeMicros(
+                    long spectrometerFeatureID, int *errorCode);
+            double spectrometerGetMaximumIntensity(
+                    long spectrometerFeatureID, int *errorCode);
+            int spectrometerGetUnformattedSpectrumLength(
+                    long spectrometerFeatureID, int *errorCode);
+            int spectrometerGetUnformattedSpectrum(long spectrometerFeatureID,
+                    int *errorCode, unsigned char *buffer, int bufferLength);
+            int spectrometerGetFormattedSpectrumLength(
+                    long spectrometerFeatureID, int *errorCode);
+            int spectrometerGetFormattedSpectrum(long spectrometerFeatureID, int *errorCode,
+                    double *buffer, int bufferLength);
+            int spectrometerGetWavelengths(long spectrometerFeatureID, int *errorCode,
+                    double *wavelengths, int length);
+            int spectrometerGetElectricDarkPixelCount(
+                    long spectrometerFeatureID, int *errorCode);
+            int spectrometerGetElectricDarkPixelIndices(
+                    long spectrometerFeatureID, int *errorCode, int *indices, int length);
+
+
+            /* Get one or more pixel binning features */
+            int getNumberOfPixelBinningFeatures();
+            int getPixelBinningFeatures(long *buffer, int maxFeatures);
+            void binningSetPixelBinningFactor(long spectrometerFeatureID, int *errorCode, const unsigned char binningFactor);
+            unsigned char binningGetPixelBinningFactor(long spectrometerFeatureID, int *errorCode);
+            void binningSetDefaultPixelBinningFactor(long spectrometerFeatureID, int *errorCode, const unsigned char binningFactor);
+            void binningSetDefaultPixelBinningFactor(long spectrometerFeatureID, int *errorCode);
+            unsigned char binningGetDefaultPixelBinningFactor(long spectrometerFeatureID, int *errorCode);
+            unsigned char binningGetMaxPixelBinningFactor(long spectrometerFeatureID, int *errorCode);
+            
+            /* Get one or more TEC features */
+            int getNumberOfThermoElectricFeatures();
+            int getThermoElectricFeatures(long *buffer, int maxFeatures);
+            double tecReadTemperatureDegreesC(long featureID, int *errorCode);
+            void tecSetTemperatureSetpointDegreesC(long featureID, int *errorCode,
+                    double temperatureDegreesCelsius);
+            void tecSetEnable(long featureID, int *errorCode, bool tecEnable);
+
+            /* Get one or more irradiance calibration features */
+            int getNumberOfIrradCalFeatures();
+            int getIrradCalFeatures(long *buffer, int maxFeatures);
+            int irradCalibrationRead(long featureID,
+                    int *errorCode, float *buffer, int bufferLength);
+            int irradCalibrationWrite(long featureID,
+                    int *errorCode, float *buffer, int bufferLength);
+            int irradCalibrationHasCollectionArea(long featureID, int *errorCode);
+            float irradCalibrationReadCollectionArea(long featureID, int *errorCode);
+            void irradCalibrationWriteCollectionArea(long featureID,
+                    int *errorCode, float area);
+
+            /* Get one or more EEPROM features */
+            int getNumberOfEEPROMFeatures();
+            int getEEPROMFeatures(long *buffer, int maxFeatures);
+            int eepromReadSlot(long featureID, int *errorCode, int slotNumber,
+                    unsigned char *buffer, int length);
+
+            /* Get one or more light source features */
+            int getNumberOfLightSourceFeatures();
+            int getLightSourceFeatures(long *buffer, int maxFeatures);
+            int lightSourceGetCount(long featureID, int *errorCode);
+            bool lightSourceHasEnable(long featureID, int *errorCode,
+                int lightSourceIndex);
+            bool lightSourceIsEnabled(long featureID, int *errorCode,
+                int lightSourceIndex);
+            void lightSourceSetEnable(long featureID, int *errorCode,
+                int lightSourceIndex, bool enable);
+            bool lightSourceHasVariableIntensity(long featureID, int *errorCode,
+                int lightSourceIndex);
+            double lightSourceGetIntensity(long featureID, int *errorCode,
+                int lightSourceIndex);
+            void lightSourceSetIntensity(long featureID, int *errorCode,
+                int lightSourceIndex, double intensity);
+
+            /* Get one or more strobe lamp enable features */
+            int getNumberOfStrobeLampFeatures();
+            int getStrobeLampFeatures(long *buffer, int maxFeatures);
+            void lampSetStrobeEnable(long featureID, int *errorCode, bool strobeEnable);
+
+            /* Get one or more continuous strobe features */
+            int getNumberOfContinuousStrobeFeatures();
+            int getContinuousStrobeFeatures(long *buffer, int maxFeatures);
+            void continuousStrobeSetPeriodMicroseconds(long featureID, int *errorCode,
+                unsigned long period_usec);
+            void continuousStrobeSetEnable(long featureID, int *errorCode, bool enable);
+
+            /* Get one or more shutter features */
+            int getNumberOfShutterFeatures();
+            int getShutterFeatures(long *buffer, int maxFeatures);
+            void shutterSetShutterOpen(long featureID, int *errorCode, bool opened);
+
+            /* Get one or more nonlinearity coefficients features */
+            int getNumberOfNonlinearityCoeffsFeatures();
+            int getNonlinearityCoeffsFeatures(long *buffer, int maxFeatures);
+            int nonlinearityCoeffsGet(long featureID, int *errorCode,
+                    double *buffer, int bufferLength);
+                    
+            /* Get one or more temperature features */
+            int getNumberOfTemperatureFeatures();
+            int getTemperatureFeatures(long *buffer, int maxFeatures);
+            unsigned char temperatureCountGet(long temperatureFeatureID, int *errorCode);
+            double temperatureGet(long temperatureFeatureID, int *errorCode, int index);
+            int temperatureGetAll(long temperatureFeatureID, int *errorCode,
+                    double *buffer, int bufferLength);
+
+            /* Get one or more revision features */
+            int getNumberOfRevisionFeatures();
+            int getRevisionFeatures(long *buffer, int maxFeatures);
+            unsigned char revisionHardwareGet(long revisionFeatureID, int *errorCode);
+            unsigned short int revisionFirmwareGet(long revisionFeatureID, int *errorCode);
+
+            /* Get one or more spectrum processing features */
+            int getNumberOfSpectrumProcessingFeatures();
+            int getSpectrumProcessingFeatures(long *buffer, int maxFeatures);
+            unsigned short int spectrumProcessingScansToAverageGet(long spectrumProcessingFeatureID, int *errorCode);
+            unsigned char spectrumProcessingBoxcarWidthGet(long spectrumProcessingFeatureID, int *errorCode);
+            void spectrumProcessingBoxcarWidthSet(long featureID, int *errorCode, unsigned char boxcarWidth);
+            void spectrumProcessingScansToAverageSet(long featureID, int *errorCode, unsigned short int scansToAverage);
+                                                   
+            /* Get one or more optical bench features */
+            int getNumberOfOpticalBenchFeatures();
+            int getOpticalBenchFeatures(long *buffer, int maxFeatures);
+            unsigned short int opticalBenchGetFiberDiameterMicrons(long opticalBenchFeatureID, int *errorCode);
+            unsigned short int opticalBenchGetSlitWidthMicrons(long opticalBenchFeatureID, int *errorCode);
+            int opticalBenchGetID(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
+            int opticalBenchGetSerialNumber(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
+            int opticalBenchGetCoating(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
+            int opticalBenchGetFilter(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
+            int opticalBenchGetGrating(long opticalBenchFeatureID, int *errorCode, char *buffer, int bufferLength);
+
+            
+            /* Get one or more stray light coefficients features */
+            int getNumberOfStrayLightCoeffsFeatures();
+            int getStrayLightCoeffsFeatures(long *buffer, int maxFeatures);
+            int strayLightCoeffsGet(long featureID, int *errorCode,
+                    double *buffer, int bufferLength);
+
+            /* Get one or more data buffer features */
+            int getNumberOfDataBufferFeatures();
+            int getDataBufferFeatures(long *buffer, int maxFeatures);
+            void dataBufferClear(long featureID, int *errorCode);
+            unsigned long dataBufferGetNumberOfElements(long featureID, int *errorCode);
+            unsigned long dataBufferGetBufferCapacity(long featureID, int *errorCode);
+            unsigned long dataBufferGetBufferCapacityMaximum(long featureID, int *errorCode);
+            unsigned long dataBufferGetBufferCapacityMinimum(long featureID, int *errorCode);
+            void dataBufferSetBufferCapacity(long featureID, int *errorCode, unsigned long capacity);
+
+            /* Get one or more acquisition delay features */
+            int getNumberOfAcquisitionDelayFeatures();
+            int getAcquisitionDelayFeatures(long *buffer, int maxFeatures);
+            void acquisitionDelaySetDelayMicroseconds(long featureID, int *errorCode,
+                unsigned long delay_usec);
+            unsigned long acquisitionDelayGetDelayMicroseconds(long featureID, int *errorCode);
+            unsigned long acquisitionDelayGetDelayIncrementMicroseconds(long featureID, int *errorCode);
+            unsigned long acquisitionDelayGetDelayMaximumMicroseconds(long featureID, int *errorCode);
+            unsigned long acquisitionDelayGetDelayMinimumMicroseconds(long featureID, int *errorCode);
+
+        protected:
+            unsigned long instanceID;
+            seabreeze::Device *device;
+            std::vector<RawUSBBusAccessFeatureAdapter *> rawUSBBusAccessFeatures;
+            std::vector<SerialNumberFeatureAdapter *> serialNumberFeatures;
+            std::vector<SpectrometerFeatureAdapter *> spectrometerFeatures;
+            std::vector<ThermoElectricCoolerFeatureAdapter *> tecFeatures;
+            std::vector<IrradCalFeatureAdapter *> irradCalFeatures;
+            std::vector<EEPROMFeatureAdapter *> eepromFeatures;
+            std::vector<LightSourceFeatureAdapter *> lightSourceFeatures;
+            std::vector<StrobeLampFeatureAdapter *> strobeLampFeatures;
+            std::vector<ContinuousStrobeFeatureAdapter *> continuousStrobeFeatures;
+            std::vector<ShutterFeatureAdapter *> shutterFeatures;
+            std::vector<NonlinearityCoeffsFeatureAdapter *> nonlinearityFeatures;
+            std::vector<TemperatureFeatureAdapter *> temperatureFeatures;
+            std::vector<RevisionFeatureAdapter *> revisionFeatures;
+            std::vector<OpticalBenchFeatureAdapter *> opticalBenchFeatures;
+            std::vector<SpectrumProcessingFeatureAdapter *> spectrumProcessingFeatures;
+            std::vector<StrayLightCoeffsFeatureAdapter *> strayLightFeatures;
+            std::vector<PixelBinningFeatureAdapter *> pixelBinningFeatures;
+            std::vector<DataBufferFeatureAdapter *> dataBufferFeatures;
+            std::vector<AcquisitionDelayFeatureAdapter *> acquisitionDelayFeatures;
+            
+            RawUSBBusAccessFeatureAdapter *getRawUSBBusAccessFeatureByID(long featureID);
+            SerialNumberFeatureAdapter *getSerialNumberFeatureByID(long featureID);
+            SpectrometerFeatureAdapter *getSpectrometerFeatureByID(long featureID);
+            ThermoElectricCoolerFeatureAdapter *getTECFeatureByID(long featureID);
+            IrradCalFeatureAdapter *getIrradCalFeatureByID(long featureID);
+            EEPROMFeatureAdapter *getEEPROMFeatureByID(long featureID);
+            LightSourceFeatureAdapter *getLightSourceFeatureByID(long featureID);
+            StrobeLampFeatureAdapter *getStrobeLampFeatureByID(long featureID);
+            ContinuousStrobeFeatureAdapter *getContinuousStrobeFeatureByID(long featureID);
+            ShutterFeatureAdapter *getShutterFeatureByID(long featureID);
+            NonlinearityCoeffsFeatureAdapter *getNonlinearityCoeffsFeatureByID(long featureID);
+            TemperatureFeatureAdapter *getTemperatureFeatureByID(long featureID);
+            RevisionFeatureAdapter *getRevisionFeatureByID(long featureID);
+            OpticalBenchFeatureAdapter *getOpticalBenchFeatureByID(long featureID);
+            SpectrumProcessingFeatureAdapter *getSpectrumProcessingFeatureByID(long featureID);
+            StrayLightCoeffsFeatureAdapter *getStrayLightCoeffsFeatureByID(long featureID);
+            PixelBinningFeatureAdapter *getPixelBinningFeatureByID(long featureID);
+            DataBufferFeatureAdapter *getDataBufferFeatureByID(long featureID);
+            AcquisitionDelayFeatureAdapter *getAcquisitionDelayFeatureByID(long featureID);
+        };
+    }
+}
+
+#endif
+

source/OSIF/include/api/seabreezeapi/EEPROMFeatureAdapter.h

@@ -0,0 +1,57 @@
+/***************************************************//**
+ * @file    EEPROMFeatureAdapter.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze EEPROMFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_EEPROMFEATUREADAPTER_H
+#define SEABREEZE_EEPROMFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/eeprom_slots/EEPROMSlotFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class EEPROMFeatureAdapter
+                : public FeatureAdapterTemplate<EEPROMSlotFeatureInterface> {
+        public:
+            EEPROMFeatureAdapter(EEPROMSlotFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~EEPROMFeatureAdapter();
+
+            /* EEPROM functions */
+            int readEEPROMSlot(int *errorCode, int slotNumber,
+                    unsigned char *buffer, int bufferLength);
+        };
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/FeatureAdapterInterface.h

@@ -0,0 +1,57 @@
+/***************************************************//**
+ * @file    FeatureAdapterInterface.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This interface allows device features to be treated
+ * consistently regardless of the actual capabilities.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_FEATUREADAPTERINTERFACE_H
+#define SEABREEZE_FEATUREADAPTERINTERFACE_H
+
+#include "common/features/FeatureFamily.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class FeatureAdapterInterface {
+        public:
+            virtual ~FeatureAdapterInterface() = 0;
+
+            /* This gets a semi-unique integer ID for this feature instance */
+            virtual long getID() = 0;
+
+            /* Gets the general category of the feature, if any */
+            virtual FeatureFamily &getFeatureFamily() = 0;
+        };
+
+        /* Default empty destructor for otherwise abstract class */
+        inline FeatureAdapterInterface::~FeatureAdapterInterface() { }
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/FeatureAdapterTemplate.h

@@ -0,0 +1,87 @@
+/***************************************************//**
+ * @file    FeatureAdapterTemplate.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a templated wrapper around SeaBreeze Feature
+ * instances.  This should make it easier to obtain a
+ * particular Feature to call methods against.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef FEATUREADAPTERTEMPLATE_H
+#define FEATUREADAPTERTEMPLATE_H
+
+#include "api/seabreezeapi/FeatureAdapterInterface.h"
+#include "common/buses/Bus.h"
+#include "common/exceptions/IllegalArgumentException.h"
+#include "common/features/FeatureFamily.h"
+#include "common/protocols/Protocol.h"
+#include <string>
+
+namespace seabreeze {
+    namespace api {
+
+        template <class T> class FeatureAdapterTemplate
+                    : public FeatureAdapterInterface {
+        public:
+            FeatureAdapterTemplate(T *featureInterface, const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex) {
+                this->feature = featureInterface;
+                this->family = f;
+                this->protocol = p;
+                this->bus = b;
+                this->index = instanceIndex;
+
+                /* Create a unique ID based on the feature type and index.  This
+                 * might be expanded in the future to use one of the bytes for
+                 * the feature type or index as a module number.
+                 */
+                this->ID = (family.getType() << 16) | (instanceIndex & 0x00FFFF);
+
+                if(0 == this->feature || 0 == this->protocol || 0 == this->bus) {
+                    std::string error("Null feature interface, protocol, or bus is not allowed.");
+                    throw IllegalArgumentException(error);
+                }
+            }
+            virtual ~FeatureAdapterTemplate() { /* Do nothing -- others delete feature */ }
+            T *getFeature() { return this->feature; }
+
+            virtual FeatureFamily &getFeatureFamily() { return this->family; }
+
+            virtual long getID() { return this->ID; }
+
+        protected:
+            T *feature;
+            FeatureFamily family;
+            Protocol *protocol;
+            Bus *bus;
+            unsigned short index;
+            unsigned long ID;
+        };
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/FeatureFamilies.h

@@ -0,0 +1,200 @@
+/***************************************************//**
+ * @file    FeatureFamilies.h
+ * @date    February 2015
+ * @author  Ocean Optics, Inc., Kirk Clendinning, Heliospectra
+ *
+ * This provides a way to get references to different kinds
+ * of features (e.g. spectrometer, TEC) generically.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_FEATUREFAMILIES_H
+#define SEABREEZE_FEATUREFAMILIES_H
+
+#include "common/features/FeatureFamily.h"
+#include <vector>
+
+namespace seabreeze {
+    namespace api {
+
+        class UndefinedFeatureFamily : public FeatureFamily {
+        public:
+            UndefinedFeatureFamily();
+            virtual ~UndefinedFeatureFamily();
+        };
+
+        class SerialNumberFeatureFamily : public FeatureFamily {
+        public:
+            SerialNumberFeatureFamily();
+            virtual ~SerialNumberFeatureFamily();
+        };
+
+        class SpectrometerFeatureFamily : public FeatureFamily {
+        public:
+            SpectrometerFeatureFamily();
+            virtual ~SpectrometerFeatureFamily();
+        };
+
+        class ThermoElectricFeatureFamily : public FeatureFamily {
+        public:
+            ThermoElectricFeatureFamily();
+            virtual ~ThermoElectricFeatureFamily();
+        };
+
+        class IrradCalFeatureFamily : public FeatureFamily {
+        public:
+            IrradCalFeatureFamily();
+            virtual ~IrradCalFeatureFamily();
+        };
+
+        class EEPROMFeatureFamily : public FeatureFamily {
+        public:
+            EEPROMFeatureFamily();
+            virtual ~EEPROMFeatureFamily();
+        };
+
+        class LightSourceFeatureFamily : public FeatureFamily {
+        public:
+            LightSourceFeatureFamily();
+            virtual ~LightSourceFeatureFamily();
+        };
+
+        class StrobeLampFeatureFamily : public FeatureFamily {
+        public:
+            StrobeLampFeatureFamily();
+            virtual ~StrobeLampFeatureFamily();
+        };
+
+        class ContinuousStrobeFeatureFamily : public FeatureFamily {
+        public:
+            ContinuousStrobeFeatureFamily();
+            virtual ~ContinuousStrobeFeatureFamily();
+        };
+
+        class ShutterFeatureFamily : public FeatureFamily {
+        public:
+            ShutterFeatureFamily();
+            virtual ~ShutterFeatureFamily();
+        };
+
+        class WaveCalFeatureFamily : public FeatureFamily {
+        public:
+            WaveCalFeatureFamily();
+            virtual ~WaveCalFeatureFamily();
+        };
+
+        class NonlinearityCoeffsFeatureFamily : public FeatureFamily {
+        public:
+            NonlinearityCoeffsFeatureFamily();
+            virtual ~NonlinearityCoeffsFeatureFamily();
+        };
+
+        class TemperatureFeatureFamily : public FeatureFamily {
+        public:
+            TemperatureFeatureFamily();
+            virtual ~TemperatureFeatureFamily();
+        };
+
+        class RevisionFeatureFamily : public FeatureFamily {
+        public:
+            RevisionFeatureFamily();
+            virtual ~RevisionFeatureFamily();
+        };
+        
+        class OpticalBenchFeatureFamily : public FeatureFamily {
+        public:
+            OpticalBenchFeatureFamily();
+            virtual ~OpticalBenchFeatureFamily();
+        };
+        
+        class SpectrumProcessingFeatureFamily : public FeatureFamily {
+        public:
+            SpectrumProcessingFeatureFamily();
+            virtual ~SpectrumProcessingFeatureFamily();
+        };
+
+        class StrayLightCoeffsFeatureFamily : public FeatureFamily {
+        public:
+            StrayLightCoeffsFeatureFamily();
+            virtual ~StrayLightCoeffsFeatureFamily();
+        };
+        
+        class RawUSBBusAccessFeatureFamily : public FeatureFamily {
+        public:
+            RawUSBBusAccessFeatureFamily();
+            virtual ~RawUSBBusAccessFeatureFamily();
+        };
+        
+        class DataBufferFeatureFamily : public FeatureFamily {
+        public:
+            DataBufferFeatureFamily();
+            virtual ~DataBufferFeatureFamily();
+        };
+
+        class AcquisitionDelayFeatureFamily : public FeatureFamily {
+        public:
+            AcquisitionDelayFeatureFamily();
+            virtual ~AcquisitionDelayFeatureFamily();
+        };
+
+        class PixelBinningFeatureFamily : public FeatureFamily {
+        public:
+            PixelBinningFeatureFamily();
+            virtual ~PixelBinningFeatureFamily();
+        };
+
+        class FeatureFamilies {
+        public:
+            const UndefinedFeatureFamily UNDEFINED;
+            const SerialNumberFeatureFamily SERIAL_NUMBER;
+            const SpectrometerFeatureFamily SPECTROMETER;
+            const ThermoElectricFeatureFamily THERMOELECTRIC;
+            const IrradCalFeatureFamily IRRAD_CAL;
+            const EEPROMFeatureFamily EEPROM;
+            const LightSourceFeatureFamily LIGHT_SOURCE;
+            const StrobeLampFeatureFamily STROBE_LAMP_ENABLE;
+            const ContinuousStrobeFeatureFamily CONTINUOUS_STROBE;
+            const ShutterFeatureFamily SHUTTER;
+            const WaveCalFeatureFamily WAVELENGTH_CAL;
+            const NonlinearityCoeffsFeatureFamily NONLINEARITY_COEFFS;
+            const TemperatureFeatureFamily TEMPERATURE;
+            const RevisionFeatureFamily REVISION;
+            const OpticalBenchFeatureFamily OPTICAL_BENCH;
+            const SpectrumProcessingFeatureFamily SPECTRUM_PROCESSING;
+            const StrayLightCoeffsFeatureFamily STRAY_LIGHT_COEFFS;
+            const RawUSBBusAccessFeatureFamily RAW_USB_BUS_ACCESS;
+            const DataBufferFeatureFamily DATA_BUFFER;
+            const AcquisitionDelayFeatureFamily ACQUISITION_DELAY;
+            const PixelBinningFeatureFamily PIXEL_BINNING;
+
+            FeatureFamilies();
+            ~FeatureFamilies();
+            std::vector<FeatureFamily *> getAllFeatureFamilies();
+        };
+    }
+}
+
+#endif
+

source/OSIF/include/api/seabreezeapi/IrradCalFeatureAdapter.h

@@ -0,0 +1,62 @@
+/***************************************************//**
+ * @file    IrradCalFeatureAdapter.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze IrradCalFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_IRRADCALFEATUREADAPTER_H
+#define SEABREEZE_IRRADCALFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/irradcal/IrradCalFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class IrradCalFeatureAdapter
+                : public FeatureAdapterTemplate<IrradCalFeatureInterface> {
+        public:
+            IrradCalFeatureAdapter(IrradCalFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~IrradCalFeatureAdapter();
+
+            int readIrradCalibration(int *errorCode, float *buffer,
+                    int bufferLength);
+            int writeIrradCalibration(int *errorCode, float *buffer,
+                    int bufferLength);
+            int hasIrradCollectionArea(int *errorCode);
+            float readIrradCollectionArea(int *errorCode);
+            void writeIrradCollectionArea(int *errorCode, float area);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/LightSourceFeatureAdapter.h

@@ -0,0 +1,69 @@
+/***************************************************//**
+ * @file    LightSourceFeatureAdapter.h
+ * @date    May 2013
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze LightSourceFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_LIGHTSOURCEFEATUREADAPTER_H
+#define SEABREEZE_LIGHTSOURCEFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/light_source/LightSourceFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class LightSourceFeatureAdapter
+                : public FeatureAdapterTemplate<LightSourceFeatureInterface> {
+        public:
+            LightSourceFeatureAdapter(LightSourceFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~LightSourceFeatureAdapter();
+
+            int getLightSourceCount(int *errorCode);
+
+            bool hasLightSourceEnable(int *errorCode, int lightSourceIndex);
+            bool isLightSourceEnabled(int *errorCode, int lightSourceIndex);
+            void setLightSourceEnable(int *errorCode, int lightSourceIndex,
+                    bool enable);
+
+            /* The intensity is normalized over the range [0, 1] where 0 is
+             * the minimum programmable intensity and 1 is the maximum
+             */
+            bool hasVariableIntensity(int *errorCode, int lightSourceIndex);
+            double getLightSourceIntensity(int *errorCode, int lightSourceIndex);
+            void setLightSourceIntensity(int *errorCode, int lightSourceIndex,
+                    double intensity);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/NonlinearityCoeffsFeatureAdapter.h

@@ -0,0 +1,57 @@
+/***************************************************//**
+ * @file    NonlinearityCoeffsFeatureAdapter.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze NonlinearityCoeffFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_NONLINEARITYCOEFFSFEATUREADAPTER_H
+#define SEABREEZE_NONLINEARITYCOEFFSFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/nonlinearity/NonlinearityCoeffsFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class NonlinearityCoeffsFeatureAdapter
+                : public FeatureAdapterTemplate<NonlinearityCoeffsFeatureInterface> {
+        public:
+            NonlinearityCoeffsFeatureAdapter(NonlinearityCoeffsFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~NonlinearityCoeffsFeatureAdapter();
+
+            int readNonlinearityCoeffs(int *errorCode, double *buffer,
+                    int bufferLength);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/OpticalBenchFeatureAdapter.h

@@ -0,0 +1,62 @@
+/***************************************************//**
+ * @file    OpticalBenchFeatureAdapter.h
+ * @date    January 2015
+ * @author  Ocean Optics, Inc., Kirk Clendinning, Heliospectra
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze TemperatureFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2015, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_OPTICALBENCHFEATUREADAPTER_H
+#define SEABREEZE_OPTICALBENCHFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/optical_bench/OpticalBenchFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class OpticalBenchFeatureAdapter
+                : public FeatureAdapterTemplate<OpticalBenchFeatureInterface> {
+        public:
+            OpticalBenchFeatureAdapter(OpticalBenchFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~OpticalBenchFeatureAdapter();
+
+            unsigned short int readOpticalBenchFiberDiameterMicrons(int *errorCode);
+        	unsigned short int readOpticalBenchSlitWidthMicrons(int *errorCode);
+            int readOpticalBenchID(int *errorCode, char *buffer, int buffer_length);
+            int readOpticalBenchSerialNumber(int *errorCode, char *buffer, int buffer_length);
+            int readOpticalBenchCoating(int *errorCode, char *buffer, int buffer_length);
+            int readOpticalBenchFilter(int *errorCode, char *buffer, int buffer_length);
+            int readOpticalBenchGrating(int *errorCode, char *buffer, int buffer_length);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/PixelBinningFeatureAdapter.h

@@ -0,0 +1,68 @@
+/***************************************************//**
+ * @file    PixelBinningFeatureAdapter.h
+ * @date    October 2015
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows access to SeaBreeze
+ * TECFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2015, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_PIXEL_BINNING_FEATURE_ADAPTER_H
+#define SEABREEZE_PIXEL_BINNING_FEATURE_ADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/pixel_binning/PixelBinningFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class PixelBinningFeatureAdapter
+                : public FeatureAdapterTemplate<PixelBinningFeatureInterface> {
+        public:
+            PixelBinningFeatureAdapter(PixelBinningFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~PixelBinningFeatureAdapter();
+
+            /* Thermoelectric cooler functions */
+            unsigned char getPixelBinningFactor(int *errorCode);
+
+            void setPixelBinningFactor(int *errorCode,
+                    const unsigned char binningFactor);
+
+            unsigned char getDefaultPixelBinningFactor(int *errorCode);
+
+            void setDefaultPixelBinningFactor(int *errorCode,
+                    const unsigned char binningFactor);
+
+            void setDefaultPixelBinningFactor(int *errorCode);
+
+            unsigned char getMaxPixelBinningFactor(int *errorCode);
+        };
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/ProtocolFamilies.h

@@ -0,0 +1,87 @@
+/***************************************************//**
+ * @file    ProtocolFamilies.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This provides a way to describe different kinds
+ * protocols (e.g. OOI, OBP) generically.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_PROTOCOLFAMILIES_H
+#define SEABREEZE_PROTOCOLFAMILIES_H
+
+#include "common/protocols/ProtocolFamily.h"
+#include <vector>
+
+namespace seabreeze {
+    namespace api {
+
+        class UndefinedProtocolFamily : public ProtocolFamily {
+        public:
+            UndefinedProtocolFamily();
+            virtual ~UndefinedProtocolFamily();
+        };
+
+        class OOIProtocolFamily : public ProtocolFamily {
+        public:
+            OOIProtocolFamily();
+            virtual ~OOIProtocolFamily();
+        };
+
+        class OceanBinaryProtocolFamily : public ProtocolFamily {
+        public:
+            OceanBinaryProtocolFamily();
+            virtual ~OceanBinaryProtocolFamily();
+        };
+
+        class JazMessagingProtocolFamily : public ProtocolFamily {
+        public:
+            JazMessagingProtocolFamily();
+            virtual ~JazMessagingProtocolFamily();
+        };
+
+        class VirtualProtocolFamily : public ProtocolFamily {
+        public:
+            VirtualProtocolFamily();
+            virtual ~VirtualProtocolFamily();
+        };
+
+        class ProtocolFamilies {
+        public:
+            const UndefinedProtocolFamily UNDEFINED_PROTOCOL;
+            const OOIProtocolFamily OOI_PROTOCOL;
+            const OceanBinaryProtocolFamily OCEAN_BINARY_PROTOCOL;
+            const JazMessagingProtocolFamily JAZ_MESSAGING_PROTOCOL;
+            const VirtualProtocolFamily VIRTUAL_PROTOCOL;
+
+            ProtocolFamilies();
+            ~ProtocolFamilies();
+            std::vector<ProtocolFamily *> getAllProtocolFamilies();
+        };
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/RawUSBBusAccessFeatureAdapter.h

@@ -0,0 +1,57 @@
+/***************************************************//**
+ * @file    RawUSBBusAccessFeatureAdapter.h
+ * @date    February 2015
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze RawUSBBusAccessFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2015, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_RAWUSBBUSACCESSFEATUREADAPTER_H
+#define SEABREEZE_RAWUSBBUSACCESSFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/raw_bus_access/RawUSBBusAccessFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class RawUSBBusAccessFeatureAdapter
+                : public FeatureAdapterTemplate<RawUSBBusAccessFeatureInterface> {
+        public:
+            RawUSBBusAccessFeatureAdapter(RawUSBBusAccessFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~RawUSBBusAccessFeatureAdapter();
+
+            int readUSB(int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char usbEndpoint);
+            int writeUSB(int *errorCode, unsigned char *buffer, unsigned int bufferLength, unsigned char usbEndpoint);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/RevisionFeatureAdapter.h

@@ -0,0 +1,58 @@
+/***************************************************//**
+ * @file    RevisionFeatureAdapter.h
+ * @date    January 2015
+ * @author  Ocean Optics, Inc., Kirk Clendinning, Heliospectra
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze RevisionFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2015, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_REVISIONFEATUREADAPTER_H
+#define SEABREEZE_REVISIONFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/revision/RevisionFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class RevisionFeatureAdapter
+                : public FeatureAdapterTemplate<RevisionFeatureInterface> {
+        public:
+            RevisionFeatureAdapter(RevisionFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~RevisionFeatureAdapter();
+
+            unsigned char readHardwareRevision(int *errorCode);
+            unsigned short int readFirmwareRevision(int *errorCode);
+
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/SeaBreezeAPIConstants.h

@@ -0,0 +1,55 @@
+/***************************************************//**
+ * @file    SeaBreezeAPIConstants.h
+ * @date    January 2015
+ * @author  Ocean Optics, Inc.
+ *
+ * This file defines constants for use with SeaBreeze API
+ * implementations.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+#ifndef SEABREEZEAPICONSTANTS_H
+#define SEABREEZEAPICONSTANTS_H
+
+/* Macros and constants */
+#define SET_ERROR_CODE(code) do { if(NULL != errorCode) { *errorCode = code; }  } while(0)
+
+#ifdef ERROR_SUCCESS
+#undef ERROR_SUCCESS
+#endif
+
+/* Constants */
+#define ERROR_SUCCESS                   0
+#define ERROR_INVALID_ERROR             1
+#define ERROR_NO_DEVICE                 2
+#define ERROR_FAILED_TO_CLOSE           3
+#define ERROR_NOT_IMPLEMENTED           4
+#define ERROR_FEATURE_NOT_FOUND         5
+#define ERROR_TRANSFER_ERROR            6
+#define ERROR_BAD_USER_BUFFER           7
+#define ERROR_INPUT_OUT_OF_BOUNDS       8
+#define ERROR_SPECTROMETER_SATURATED    9
+#define ERROR_VALUE_NOT_FOUND           10
+
+#endif /* SEABREEZEAPICONSTANTS_H */

source/OSIF/include/api/seabreezeapi/SerialNumberFeatureAdapter.h

@@ -0,0 +1,58 @@
+/***************************************************//**
+ * @file    SerialNumberFeatureAdapter.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze SerialNumberFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_SERIALNUMBERFEATUREADAPTER_H
+#define SEABREEZE_SERIALNUMBERFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/serial_number/SerialNumberFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class SerialNumberFeatureAdapter
+                : public FeatureAdapterTemplate<SerialNumberFeatureInterface> {
+        public:
+            SerialNumberFeatureAdapter(SerialNumberFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~SerialNumberFeatureAdapter();
+
+            int getSerialNumber(int *errorCode, char *buffer, int buffer_length);
+            unsigned char getSerialNumberMaximumLength(int *errorCode);
+
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/ShutterFeatureAdapter.h

@@ -0,0 +1,56 @@
+/***************************************************//**
+ * @file    ShutterFeatureAdapter.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze ShutterFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_SHUTTERFEATUREADAPTER_H
+#define SEABREEZE_SHUTTERFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/shutter/ShutterFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class ShutterFeatureAdapter
+                : public FeatureAdapterTemplate<ShutterFeatureInterface> {
+        public:
+            ShutterFeatureAdapter(ShutterFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~ShutterFeatureAdapter();
+
+            void setShutterOpen(int *errorCode, bool open);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/SpectrometerFeatureAdapter.h

@@ -0,0 +1,74 @@
+/***************************************************//**
+ * @file    SpectrometerFeatureAdapter.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze OOISpectrometerFeature instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_SPECTROMETER_FEATURE_ADAPTER_H
+#define SEABREEZE_SPECTROMETER_FEATURE_ADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "common/buses/Bus.h"
+#include "common/protocols/Protocol.h"
+#include "vendors/OceanOptics/features/spectrometer/OOISpectrometerFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class SpectrometerFeatureAdapter : public FeatureAdapterTemplate<OOISpectrometerFeatureInterface> {
+        public:
+            SpectrometerFeatureAdapter(
+                OOISpectrometerFeatureInterface *spec,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~SpectrometerFeatureAdapter();
+
+            /* Spectrometer commands */
+            int getUnformattedSpectrum(int *errorCode,
+                    unsigned char *buffer, int bufferLength);
+            int getFormattedSpectrum(int *errorCode,
+                    double* buffer, int bufferLength);
+            int getUnformattedSpectrumLength(int *errorCode);
+            int getFormattedSpectrumLength(int *errorCode);
+            void setTriggerMode(int *errorCode, int mode);
+            int getWavelengths(int *errorCode, double *wavelengths, int length);
+            int getElectricDarkPixelCount(int *errorCode);
+            int getElectricDarkPixelIndices(int *errorCode,
+                    int *indices, int length);
+            void setIntegrationTimeMicros(int *errorCode,
+                    unsigned long integrationTimeMicros);
+            long getMinimumIntegrationTimeMicros(int *errorCode);
+            long getMaximumIntegrationTimeMicros(int *errorCode);
+            double getMaximumIntensity(int *errorCode);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/SpectrumProcessingFeatureAdapter.h

@@ -0,0 +1,60 @@
+/***************************************************//**
+ * @file    SpectrumProcessingFeatureAdapter.h
+ * @date    January 2015
+ * @author  Ocean Optics, Inc., Kirk Clendinning, Heliospectra
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze SpectrumProcessingFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2015, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_SPECTRUMPROCESSINGFEATUREADAPTER_H
+#define SEABREEZE_SPECTRUMPROCESSINGFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/spectrum_processing/SpectrumProcessingFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class SpectrumProcessingFeatureAdapter
+                : public FeatureAdapterTemplate<SpectrumProcessingFeatureInterface> {
+        public:
+            SpectrumProcessingFeatureAdapter(SpectrumProcessingFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~SpectrumProcessingFeatureAdapter();
+
+			unsigned char readSpectrumProcessingBoxcarWidth(int *errorCode);
+            unsigned short int readSpectrumProcessingScansToAverage(int *errorCode);
+            void writeSpectrumProcessingBoxcarWidth(int *errorCode, unsigned char boxcarWidth);
+            void writeSpectrumProcessingScansToAverage(int *errorCode, unsigned short int scansToAverage);
+
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/StrayLightCoeffsFeatureAdapter.h

@@ -0,0 +1,57 @@
+/***************************************************//**
+ * @file    StrayLightCoeffsFeatureAdapter.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze StrayLightCoeffFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_STRAYLIGHTCOEFFSFEATUREADAPTER_H
+#define SEABREEZE_STRAYLIGHTCOEFFSFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/stray_light/StrayLightCoeffsFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class StrayLightCoeffsFeatureAdapter
+                : public FeatureAdapterTemplate<StrayLightCoeffsFeatureInterface> {
+        public:
+            StrayLightCoeffsFeatureAdapter(StrayLightCoeffsFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~StrayLightCoeffsFeatureAdapter();
+
+            int readStrayLightCoeffs(int *errorCode, double *buffer,
+                    int bufferLength);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/StrobeLampFeatureAdapter.h

@@ -0,0 +1,56 @@
+/***************************************************//**
+ * @file    StrobeLampFeatureAdapter.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze StrobeLampFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_STROBELAMPFEATUREADAPTER_H
+#define SEABREEZE_STROBELAMPFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/light_source/StrobeLampFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class StrobeLampFeatureAdapter
+                : public FeatureAdapterTemplate<StrobeLampFeatureInterface> {
+        public:
+            StrobeLampFeatureAdapter(StrobeLampFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~StrobeLampFeatureAdapter();
+
+            void setStrobeLampEnable(int *errorCode, bool enable);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/TemperatureFeatureAdapter.h

@@ -0,0 +1,58 @@
+/***************************************************//**
+ * @file    TemperatureFeatureAdapter.h
+ * @date    January 2015
+ * @author  Ocean Optics, Inc., Kirk Clendinning, Heliospectra
+ *
+ * This is a wrapper that allows
+ * access to SeaBreeze TemperatureFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2015, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_TEMPERATUREFEATUREADAPTER_H
+#define SEABREEZE_TEMPERATUREFEATUREADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/temperature/TemperatureFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class TemperatureFeatureAdapter
+                : public FeatureAdapterTemplate<TemperatureFeatureInterface> {
+        public:
+            TemperatureFeatureAdapter(TemperatureFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~TemperatureFeatureAdapter();
+
+			unsigned char readTemperatureCount(int *errorCode);
+            double readTemperature(int *errorCode, int index);
+            int readAllTemperatures(int *errorCode, double *buffer, int bufferLength);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/api/seabreezeapi/ThermoElectricCoolerFeatureAdapter.h

@@ -0,0 +1,61 @@
+/***************************************************//**
+ * @file    ThermoElectricCoolerFeatureAdapter.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a wrapper that allows access to SeaBreeze
+ * TECFeatureInterface instances.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_THERMO_ELECTRIC_COOLER_FEATURE_ADAPTER_H
+#define SEABREEZE_THERMO_ELECTRIC_COOLER_FEATURE_ADAPTER_H
+
+#include "api/seabreezeapi/FeatureAdapterTemplate.h"
+#include "vendors/OceanOptics/features/thermoelectric/ThermoElectricFeatureInterface.h"
+
+namespace seabreeze {
+    namespace api {
+
+        class ThermoElectricCoolerFeatureAdapter
+                : public FeatureAdapterTemplate<ThermoElectricFeatureInterface> {
+        public:
+            ThermoElectricCoolerFeatureAdapter(ThermoElectricFeatureInterface *intf,
+                    const FeatureFamily &f,
+                    Protocol *p, Bus *b, unsigned short instanceIndex);
+            virtual ~ThermoElectricCoolerFeatureAdapter();
+
+            /* Thermoelectric cooler functions */
+            double readTECTemperature(int *errorCode);
+            void setTECTemperature(int *errorCode,
+                    double temperature_degrees_celsius);
+            void setTECEnable(int *errorCode, bool tecEnable);
+            void setTECFanEnable(int *errorCode, bool tecFanEnable);
+        };
+
+    }
+}
+
+#endif

source/OSIF/include/common/ByteVector.h

@@ -0,0 +1,63 @@
+/***************************************************//**
+ * @file    ByteVector.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_BYTEVECTOR_H
+#define SEABREEZE_BYTEVECTOR_H
+
+#include "common/SeaBreeze.h"
+#include "common/Data.h"
+#include <vector>
+
+namespace seabreeze {
+
+    class ByteVector : public Data {
+    public:
+        ByteVector();
+        /* Constructor that makes a copy of the given vector for internal use */
+        ByteVector(const std::vector<byte> &that);
+        virtual ~ByteVector();
+        /* Dimensionality of data.  0 for scalar, 1 for vector,
+         * 2 for a pair of related vectors (e.g. [X, Y] or matrix),
+         * 3 for 3D, etc.
+         */
+        virtual int getNumberOfDimensions();
+
+        /* Get all of the unit descriptors associated with this Data. */
+        virtual std::vector<UnitDescriptor *> *getUnits();
+
+        /* Get the data associated with this instance */
+        std::vector<byte> &getByteVector();
+
+    private:
+        std::vector<byte> *data;
+    };
+
+}
+
+#endif

source/OSIF/include/common/Data.h

@@ -0,0 +1,62 @@
+/***************************************************//**
+ * @file    Data.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a sort of a wrapper class that can encapsulate
+ * different kinds of data that may be returned as the
+ * result of a protocol transfer.  The idea is that the
+ * data being passed back up from the device probably needs
+ * to be in some specific form, but we need to be able
+ * to convert it to whatever the receiver can use.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_DATA_H
+#define SEABREEZE_DATA_H
+
+#include "common/SeaBreeze.h"
+#include "common/UnitDescriptor.h"
+#include <vector>
+
+namespace seabreeze {
+
+    class Data {
+    public:
+        Data();
+        virtual ~Data();
+        /* Dimensionality of data.  0 for scalar, 1 for vector,
+         * 2 for a pair of related vectors (e.g. [X, Y] or matrix),
+         * 3 for 3D, etc.
+         */
+        virtual int getNumberOfDimensions();
+
+        /* Get all of the unit descriptors associated with this Data. */
+        virtual std::vector<UnitDescriptor *> *getUnits();
+    };
+
+}
+
+#endif

source/OSIF/include/common/DoubleVector.h

@@ -0,0 +1,62 @@
+/***************************************************//**
+ * @file    DoubleVector.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_DOUBLEVECTOR_H
+#define SEABREEZE_DOUBLEVECTOR_H
+
+#include <vector>
+#include "common/SeaBreeze.h"
+#include "common/Data.h"
+
+namespace seabreeze {
+
+    class DoubleVector : public Data {
+    public:
+        DoubleVector();
+        DoubleVector(const std::vector<double> &that);
+        virtual ~DoubleVector();
+        /* Dimensionality of data.  0 for scalar, 1 for vector,
+         * 2 for a pair of related vectors (e.g. [X, Y] or matrix),
+         * 3 for 3D, etc.
+         */
+        virtual int getNumberOfDimensions();
+
+        /* Get all of the unit descriptors associated with this Data. */
+        virtual std::vector<UnitDescriptor *> *getUnits();
+
+        /* Get the data associated with this instance */
+        std::vector<double> &getDoubleVector();
+
+    private:
+        std::vector<double> *data;
+    };
+
+}
+
+#endif

source/OSIF/include/common/FloatVector.h

@@ -0,0 +1,62 @@
+/***************************************************//**
+ * @file    FloatVector.h
+ * @date    March 2010
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_FLOATVECTOR_H
+#define SEABREEZE_FLOATVECTOR_H
+
+#include <vector>
+#include "common/SeaBreeze.h"
+#include "common/Data.h"
+
+namespace seabreeze {
+
+    class FloatVector : public Data {
+    public:
+        FloatVector();
+        FloatVector(const std::vector<float> &that);
+        virtual ~FloatVector();
+        /* Dimensionality of data.  0 for scalar, 1 for vector,
+         * 2 for a pair of related vectors (e.g. [X, Y] or matrix),
+         * 3 for 3D, etc.
+         */
+        virtual int getNumberOfDimensions();
+
+        /* Get all of the unit descriptors associated with this Data. */
+        virtual std::vector<UnitDescriptor *> *getUnits();
+
+        /* Get the data associated with this instance */
+        std::vector<float> &getFloatVector();
+
+    private:
+        std::vector<float> *data;
+    };
+
+}
+
+#endif

source/OSIF/include/common/Log.h

@@ -0,0 +1,132 @@
+/**
+    @file   Log.h
+    @brief  Interface to Log
+    @author Mark Zieg <mark.zieg@oceanoptics.com>
+
+    LICENSE:
+
+    SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject
+    to the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef SEABREEZE_LOG_H
+#define SEABREEZE_LOG_H
+
+#include "api/DllDecl.h"
+
+#include <string>
+#include <stack>
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifdef OOI_DEBUG
+    #define OOI_LOG_PRINT 1
+#else
+    #define OOI_LOG_PRINT 0
+#endif
+
+#ifdef __cplusplus
+
+/**
+* @brief instantiate logger in the current function
+* @param s (Input) function name (typically __FUNCTION__)
+*/
+#define LOG(s) Log logger(s);
+
+/**
+* @brief log a printf string (and optional arguments) if debugging is enabled
+* @note double parens: call as LOG_DEBUG(("variable x is %d, y is %f", x, y));
+* @see http://stackoverflow.com/questions/1644868/c-define-macro-for-debug-printing
+*/
+#define LOG_DEBUG(s) do { if (OOI_LOG_PRINT) logger.debug s; } while (0)
+
+//! @see LOG_DEBUG
+#define LOG_INFO(s)  do { if (OOI_LOG_PRINT) logger.info  s; } while (0)
+
+//! @see LOG_DEBUG
+#define LOG_WARN(s)  do { if (OOI_LOG_PRINT) logger.warn  s; } while (0)
+
+//! @see LOG_DEBUG
+#define LOG_ERROR(s) do { if (OOI_LOG_PRINT) logger.error s; } while (0)
+
+#define OOI_LOG_LEVEL_NEVER 0
+#define OOI_LOG_LEVEL_ERROR 1
+#define OOI_LOG_LEVEL_WARN  2
+#define OOI_LOG_LEVEL_INFO  3
+#define OOI_LOG_LEVEL_DEBUG 4
+#define OOI_LOG_LEVEL_TRACE 5
+
+/**
+* @brief Simple logger for OOI applications.
+* @todo  Provide better thread support (hard to tell what thread model
+*        the caller may be using...)
+* @todo  Provide flat C interface (e.g. for NativeUSBWinUSB.c, test apps)
+*
+* Provides automatic heirarchical call-stack indentation.
+*/
+class DLL_DECL Log
+{
+    public:
+        Log(const char *s);
+       ~Log();
+
+        // public class methods
+        static void setLogLevel(int lvl);
+        static void setLogLevel(const std::string& s);
+        static void setLogFile(void *f);
+
+        // public instance methods
+        void debug(const char *fmt, ...);
+        void info (const char *fmt, ...);
+        void warn (const char *fmt, ...);
+        void error(const char *fmt, ...);
+
+        // these must be public for C interface to work
+        static unsigned logLevel;
+        void formatAndSend(int lvl, const char *lvlName,
+            const char *separator, const char *fmt, va_list args);
+
+    private:
+        // private class attributes
+        static FILE *logFile;
+        static std::stack<std::string>* callstack;
+
+        // private instance methods
+        void trace(const char *fmt, ...);
+};
+
+extern "C" {
+#endif /* __cplusplus */
+
+// We need the flattened C interface if we want to call from Cygwin (mainly
+// to set log level)...see http://cygwin.com/ml/cygwin/2006-04/msg00251.html
+void DLL_DECL seabreeze_log_set_level_int(int lvl);
+void DLL_DECL seabreeze_log_set_level_string(const char *s);
+void DLL_DECL seabreeze_log_debug(const char *fmt, ...);
+void DLL_DECL seabreeze_log_info (const char *fmt, ...);
+void DLL_DECL seabreeze_log_warn (const char *fmt, ...);
+void DLL_DECL seabreeze_log_error(const char *fmt, ...);
+
+#ifdef __cplusplus
+};
+
+#endif /* __cplusplus */
+#endif

source/OSIF/include/common/SeaBreeze.h

@@ -0,0 +1,45 @@
+/***************************************************//**
+ * @file    SeaBreeze.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This provides some project-wide constants and definitions.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_H
+#define SEABREEZE_H
+
+typedef unsigned char byte;
+
+#ifdef WINDOWS
+/* Visual studio does not implement declared exception
+ * specification but accepts it with a warning.  This
+ * suppresses the warning (4290).
+ */
+#pragma warning( disable : 4290 )
+#endif /* WINDOWS */
+
+#endif /* SEABREEZE_H */

source/OSIF/include/common/U32Vector.h

@@ -0,0 +1,77 @@
+/***************************************************//**
+ * @file    U32Vector.h
+ * @date    September 2013
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_U32VECTOR_H
+#define SEABREEZE_U32VECTOR_H
+
+#include <vector>
+#include "common/SeaBreeze.h"
+#include "common/Data.h"
+
+/* This class requires a 32-bit integer type.  This will need a little help
+ * to know what the target machine is, so this tries to work it out.
+ */
+#ifdef _MSC_VER
+/* Visual Studio */
+typedef __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+#else
+/* C99 compatible */
+#include <stdint.h>
+#endif
+
+
+namespace seabreeze {
+
+    class U32Vector : public Data {
+    public:
+        U32Vector();
+        /* Constructor that makes a copy of the given vector for internal use */
+        U32Vector(const std::vector<uint32_t> &that);
+        U32Vector(unsigned int length);
+        virtual ~U32Vector();
+        /* Dimensionality of data.  0 for scalar, 1 for vector,
+         * 2 for a pair of related vectors (e.g. [X, Y] or matrix),
+         * 3 for 3D, etc.
+         */
+        virtual int getNumberOfDimensions();
+
+        /* Get all of the unit descriptors associated with this Data. */
+        virtual std::vector<UnitDescriptor *> *getUnits();
+
+        /* Get the data associated with this instance */
+        std::vector<uint32_t> &getU32Vector();
+
+    private:
+        std::vector<uint32_t> *data;
+    };
+
+}
+
+#endif

source/OSIF/include/common/UShortVector.h

@@ -0,0 +1,64 @@
+/***************************************************//**
+ * @file    UShortVector.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_USHORTVECTOR_H
+#define SEABREEZE_USHORTVECTOR_H
+
+#include <vector>
+#include "common/SeaBreeze.h"
+#include "common/Data.h"
+
+namespace seabreeze {
+
+    class UShortVector : public Data {
+    public:
+        UShortVector();
+        /* Constructor that makes a copy of the given vector for internal use */
+        UShortVector(const std::vector<unsigned short> &that);
+        UShortVector(unsigned int length);
+        virtual ~UShortVector();
+        /* Dimensionality of data.  0 for scalar, 1 for vector,
+         * 2 for a pair of related vectors (e.g. [X, Y] or matrix),
+         * 3 for 3D, etc.
+         */
+        virtual int getNumberOfDimensions();
+
+        /* Get all of the unit descriptors associated with this Data. */
+        virtual std::vector<UnitDescriptor *> *getUnits();
+
+        /* Get the data associated with this instance */
+        std::vector<unsigned short> &getUShortVector();
+
+    private:
+        std::vector<unsigned short> *data;
+    };
+
+}
+
+#endif

source/OSIF/include/common/UnitDescriptor.h

@@ -0,0 +1,46 @@
+/***************************************************//**
+ * @file    UnitDescriptor.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_UNITDESCRIPTOR_H
+#define SEABREEZE_UNITDESCRIPTOR_H
+
+namespace seabreeze {
+
+    class UnitDescriptor {
+    public:
+        UnitDescriptor();
+        ~UnitDescriptor();
+
+        /* FIXME: need to define unit property getters */
+
+    };
+
+}
+
+#endif

source/OSIF/include/common/buses/Bus.h

@@ -0,0 +1,66 @@
+/***************************************************//**
+ * @file    Bus.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This provides a base class for all sorts of buses.  A bus
+ * is a mechanism for transferring a stream of data from one
+ * point to another.  The bus does not concern itself with the
+ * contents of the data stream.  At most, it may use hints to
+ * determine how a particular message will be moved if this
+ * is necessary to complete the operation.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_BUS_H
+#define SEABREEZE_BUS_H
+
+#include "common/protocols/ProtocolHint.h"
+#include "common/buses/TransferHelper.h"
+#include "common/buses/BusFamily.h"
+#include "common/buses/DeviceLocatorInterface.h"
+#include "common/exceptions/IllegalArgumentException.h"
+
+namespace seabreeze {
+
+    class Bus {
+    public:
+        Bus();
+        virtual ~Bus();
+        virtual TransferHelper *getHelper(const std::vector<ProtocolHint *> &hints) const = 0;
+        virtual BusFamily getBusFamily() const = 0;
+        /* Associate this Bus instance with a particular device location.
+         * This MUST be done before open or close can be used.
+         */
+        virtual void setLocation(const DeviceLocatorInterface &location)
+                throw (IllegalArgumentException) = 0;
+        virtual bool open() = 0;
+        virtual void close() = 0;
+        virtual DeviceLocatorInterface *getLocation() = 0;
+    };
+
+}
+
+#endif

source/OSIF/include/common/buses/BusFamilies.h

@@ -0,0 +1,86 @@
+/***************************************************//**
+ * @file    BusFamilies.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This provides a way to get references to different kinds of buses
+ * (e.g. USB, Ethernet, serial) generically.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef BUSFAMILIES_H
+#define BUSFAMILIES_H
+
+#include "common/buses/BusFamily.h"
+#include <vector>
+
+namespace seabreeze {
+
+    class USBBusFamily : public BusFamily {
+    public:
+        USBBusFamily();
+        virtual ~USBBusFamily();
+    };
+
+    class EthernetBusFamily : public BusFamily {
+    public:
+        EthernetBusFamily();
+        virtual ~EthernetBusFamily();
+    };
+
+    class RS232BusFamily : public BusFamily {
+    public:
+        RS232BusFamily();
+        virtual ~RS232BusFamily();
+    };
+    
+    class TCPIPv4BusFamily : public BusFamily {
+    public:
+        TCPIPv4BusFamily();
+        virtual ~TCPIPv4BusFamily();
+    };
+    
+    class UDPIPv4BusFamily : public BusFamily {
+    public:
+        UDPIPv4BusFamily();
+        virtual ~UDPIPv4BusFamily();
+    };
+
+    class BusFamilies {
+    public:
+        const USBBusFamily USB;
+        const EthernetBusFamily ETHERNET;
+        const RS232BusFamily RS232;
+        const TCPIPv4BusFamily TCPIPv4;
+        const UDPIPv4BusFamily UDPIPv4;
+
+        BusFamilies();
+        ~BusFamilies();
+        std::vector<BusFamily *> getAllBusFamilies();
+    };
+
+}
+
+#endif /* BUSFAMILIES_H */

source/OSIF/include/common/buses/BusFamily.h

@@ -0,0 +1,54 @@
+/***************************************************//**
+ * @file    BusFamily.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This provides a way to describe different kinds of buses
+ * (e.g. USB, Ethernet, serial) generically.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+#ifndef BUSFAMILY_H
+#define BUSFAMILY_H
+
+#include <string>
+
+namespace seabreeze {
+    class BusFamily {
+    public:
+        virtual ~BusFamily();
+        virtual std::string getName() const;
+        virtual bool equals(const BusFamily &that);
+
+    protected:
+        BusFamily(std::string name, int id);
+
+    private:
+        std::string busName;
+        int type;
+    };
+
+}
+
+#endif /* BUSFAMILY_H */

source/OSIF/include/common/buses/DeviceLocationProberInterface.h

@@ -0,0 +1,58 @@
+/***************************************************//**
+ * @file    DeviceLocationProberInterface.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * DeviceLocatorInterface provides a base interface for
+ * classes that allow the location of a device to be
+ * probed in a bus-specific way.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef DEVICELOCATIONPROBERINTERFACE_H
+#define DEVICELOCATIONPROBERINTERFACE_H
+
+#include <vector>
+#include "common/buses/DeviceLocatorInterface.h"
+
+namespace seabreeze {
+
+    class DeviceLocationProberInterface {
+    public:
+        virtual ~DeviceLocationProberInterface() = 0;
+
+        /* Report how many devices of this type are available */
+        virtual std::vector<DeviceLocatorInterface *> *probeDevices() = 0;
+
+    protected:
+        DeviceLocationProberInterface();
+    };
+
+    /* Default implementation for (otherwise) pure virtual destructor */
+    inline DeviceLocationProberInterface::~DeviceLocationProberInterface() {}
+
+}
+
+#endif /* DEVICELOCATIONPROBERINTERFACE_H */

source/OSIF/include/common/buses/DeviceLocatorInterface.h

@@ -0,0 +1,82 @@
+/***************************************************//**
+ * @file    DeviceLocatorInterface.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * DeviceLocatorInterface provides a base interface for
+ * classes that allow the location of a device to be
+ * specified in a bus-specific way.  For instance, a
+ * USB DeviceLocator might include a device path or
+ * index, and a socket DeviceLocator might include an
+ * IP address and port number.  This allows
+ * devices that cannot be identified by probing to still
+ * be found easily.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef DEVICELOCATORINTERFACE_H
+#define DEVICELOCATORINTERFACE_H
+
+#include <string>
+#include "common/buses/BusFamily.h"
+
+namespace seabreeze {
+
+    class DeviceLocatorInterface {
+    public:
+        virtual ~DeviceLocatorInterface() = 0;
+
+        /**
+         * Get a unique identifier for this location.  This can be any value
+         * as long as it is globally unique.
+         */
+        virtual unsigned long getUniqueLocation() const = 0;
+
+        /**
+         * Determine whether this DeviceLocator refers to the same device
+         * as another.
+         */
+        virtual bool equals(DeviceLocatorInterface &that) = 0;
+
+        /**
+         * Get a human-readable string that describes the location
+         */
+        virtual std::string getDescription() = 0;
+
+        /**
+         * Get a description of the type of bus that the device is associated with
+         */
+        virtual BusFamily getBusFamily() const = 0;
+
+        /* Get an exact copy of this instance */
+        virtual DeviceLocatorInterface *clone() const = 0;
+    };
+
+    /* Default implementation for (otherwise) pure virtual destructor */
+    inline DeviceLocatorInterface::~DeviceLocatorInterface() {}
+
+}
+
+#endif /* DEVICELOCATORINTERFACE_H */

source/OSIF/include/common/buses/TransferHelper.h

@@ -0,0 +1,58 @@
+/***************************************************//**
+ * @file    TransferHelper.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is effectively an interface for wrappers around bus
+ * activity.  These wrappers may be selected from a Bus
+ * based on certain hints provided by a Protocol or its
+ * various Exchanges.  All that this specifies is that a
+ * given object must be able to send() and receive() data
+ * across its particular (encapsulated) Bus.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_TRANSFERHELPER_H
+#define SEABREEZE_TRANSFERHELPER_H
+
+#include "common/SeaBreeze.h"
+#include "common/exceptions/BusTransferException.h"
+#include <vector>
+
+namespace seabreeze {
+
+    class TransferHelper {
+    public:
+        TransferHelper();
+        virtual ~TransferHelper();
+        virtual int receive(std::vector<byte> &buffer, unsigned int length)
+            throw (BusTransferException) = 0;
+        virtual int send(const std::vector<byte> &buffer, unsigned int length) const
+            throw (BusTransferException) = 0;
+    };
+
+}
+
+#endif

source/OSIF/include/common/buses/network/IPv4NetworkProtocol.h

@@ -0,0 +1,75 @@
+/***************************************************//**
+ * @file    IPv4NetworkProtocol.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_IPV4NETWORKPROTOCOL_H
+#define SEABREEZE_IPV4NETWORKPROTOCOL_H
+
+#include <string>
+#include <vector>
+
+namespace seabreeze {
+    class IPv4NetworkProtocol {
+    public:
+        virtual ~IPv4NetworkProtocol();
+        virtual std::string getName() const;
+        virtual bool equals(const IPv4NetworkProtocol &that) const;
+
+    protected:
+        IPv4NetworkProtocol(std::string name, int id);
+
+    private:
+        std::string protocolName;
+        int type;
+    };
+    
+    class TCP_IPv4 : public IPv4NetworkProtocol {
+    public:
+        TCP_IPv4();
+        virtual ~TCP_IPv4();
+    };
+    
+    class UDP_IPv4 : public IPv4NetworkProtocol {
+    public:
+        UDP_IPv4();
+        virtual ~UDP_IPv4();
+    };
+
+    class IPv4NetworkProtocols {
+    public:
+        const TCP_IPv4 TCP_IP4;
+        const UDP_IPv4 UDP_IP4;
+
+        IPv4NetworkProtocols();
+        ~IPv4NetworkProtocols();
+        std::vector<IPv4NetworkProtocol *> getAllIPv4NetworkProtocols();
+    };
+}
+
+#endif /* SEABREEZE_IPV4NETWORKPROTOCOL_H */
+

source/OSIF/include/common/buses/network/IPv4SocketDeviceLocator.h

@@ -0,0 +1,66 @@
+/***************************************************//**
+ * @file    IPv4SocketDeviceLocator.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_IPV4SOCKETDEVICELOCATOR_H
+#define SEABREEZE_IPV4SOCKETDEVICELOCATOR_H
+
+#include "common/buses/DeviceLocatorInterface.h"
+#include "common/buses/network/IPv4NetworkProtocol.h"
+#include <string>
+
+namespace seabreeze {
+    class IPv4SocketDeviceLocator : public DeviceLocatorInterface {
+    public:
+        IPv4SocketDeviceLocator(const IPv4NetworkProtocol &proto, std::string ip,
+            int portNumber);
+        virtual ~IPv4SocketDeviceLocator();
+        
+        std::string getIPv4Address();
+        int getPort();
+        IPv4NetworkProtocol getIPv4NetworkProtocol();
+        
+        /* Inherited from DeviceLocatorInterface */
+        virtual unsigned long getUniqueLocation() const;
+        virtual bool equals(DeviceLocatorInterface &that);
+        virtual std::string getDescription();
+        virtual BusFamily getBusFamily() const;
+        virtual DeviceLocatorInterface *clone() const;
+        
+    protected:
+        unsigned long computeLocationHash();
+        
+        IPv4NetworkProtocol protocol;
+        std::string ipAddr;
+        int port;
+        unsigned long locationHash;
+    };
+}
+
+#endif /* SEABREEZE_IPV4SOCKETDEVICELOCATOR_H */
+

source/OSIF/include/common/buses/network/TCPIPv4SocketBus.h

@@ -0,0 +1,75 @@
+/***************************************************//**
+ * @file    TCPIPv4SocketBus.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_TCPIPV4SOCKETBUS_H
+#define SEABREEZE_TCPIPV4SOCKETBUS_H
+
+#include "common/buses/Bus.h"
+#include "common/exceptions/IllegalArgumentException.h"
+#include "native/network/Socket.h"
+#include <vector>
+
+namespace seabreeze {
+    class TCPIPv4SocketBus : public Bus {
+    public:
+        TCPIPv4SocketBus();
+        virtual ~TCPIPv4SocketBus();
+        
+        virtual Socket *getSocketDescriptor();
+        
+        virtual BusFamily getBusFamily() const;
+        
+        virtual void setLocation(const DeviceLocatorInterface &location)
+                throw (IllegalArgumentException);
+        virtual DeviceLocatorInterface *getLocation();
+        virtual TransferHelper *getHelper(
+                const std::vector<ProtocolHint *> &hints) const;
+        
+        /* Pure virtual methods */
+        virtual bool open() = 0;
+        virtual void close() = 0;
+        
+        
+    protected:
+        void addHelper(ProtocolHint *hint, TransferHelper *helper);
+        void clearHelpers();
+        
+        Socket *socket;
+        DeviceLocatorInterface *deviceLocator;
+        
+        /* These vectors should really be in a map, but that didn't want to
+         * work easily.  Since there will likely be about 2 entries in here,
+         * storing in a pair of vectors for now won't hurt anything.
+         */
+        std::vector<ProtocolHint *> helperKeys;
+        std::vector<TransferHelper *> helperValues;
+    };
+}
+
+#endif /* SEABREEZE_TCPIPV4SOCKETBUS_H */

source/OSIF/include/common/buses/network/TCPIPv4SocketTransferHelper.h

@@ -0,0 +1,52 @@
+/***************************************************//**
+ * @file    TCPIPv4SocketTransferHelper.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_TCPIPV4SOCKETTRANSFERHELPER_H
+#define SEABREEZE_TCPIPV4SOCKETTRANSFERHELPER_H
+
+#include "common/buses/TransferHelper.h"
+#include "native/network/Socket.h"
+
+namespace seabreeze {
+    class TCPIPv4SocketTransferHelper : public TransferHelper {
+    public:
+        TCPIPv4SocketTransferHelper(Socket *sock);
+        virtual ~TCPIPv4SocketTransferHelper();
+        
+        virtual int receive(std::vector<byte> &buffer, unsigned int length)
+            throw (BusTransferException);
+        virtual int send(const std::vector<byte> &buffer, unsigned int length) const
+            throw (BusTransferException);
+        
+    protected:
+        Socket *socket;
+    };
+}
+
+#endif /* SEABREEZE_TCPIPV4SOCKETTRANSFERHELPER_H */

source/OSIF/include/common/buses/rs232/RS232DeviceLocator.h

@@ -0,0 +1,65 @@
+/***************************************************//**
+ * @file    RS232DeviceLocator.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This class encapsulates the information needed to open
+ * a device on an RS232 bus.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef RS232DEVICELOCATOR_H
+#define RS232DEVICELOCATOR_H
+
+#include "common/buses/DeviceLocatorInterface.h"
+#include <string>
+
+namespace seabreeze {
+
+    class RS232DeviceLocator : public DeviceLocatorInterface {
+    public:
+        RS232DeviceLocator(std::string devicePath, int baudRate);
+        virtual ~RS232DeviceLocator();
+
+        std::string &getDevicePath();
+        int getBaudRate();
+
+        /* Inherited from DeviceLocatorInterface */
+        virtual unsigned long getUniqueLocation() const;
+        virtual bool equals(DeviceLocatorInterface &that);
+        virtual std::string getDescription();
+        virtual BusFamily getBusFamily() const;
+        virtual DeviceLocatorInterface *clone() const;
+
+    private:
+        void computeLocationHash();
+        std::string devicePath;
+        int baudRate;
+        unsigned long locationHash;
+    };
+
+}
+
+#endif /* RS232DEVICELOCATOR_H */

source/OSIF/include/common/buses/rs232/RS232Interface.h

@@ -0,0 +1,63 @@
+/***************************************************//**
+ * @file    RS232Interface.h
+ * @date    April 2011
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef RS232INTERFACE_H
+#define RS232INTERFACE_H
+
+#include "common/buses/Bus.h"
+#include "native/rs232/NativeRS232.h"
+#include "native/rs232/RS232.h"
+#include "common/exceptions/IllegalArgumentException.h"
+
+namespace seabreeze {
+
+    class RS232Interface : public Bus {
+    public:
+        RS232Interface();
+        virtual ~RS232Interface();
+        virtual RS232 *getRS232Descriptor();
+        virtual DeviceLocatorInterface *getLocation();
+        virtual void setLocation(const DeviceLocatorInterface &location)
+                throw (IllegalArgumentException);
+        virtual BusFamily getBusFamily() const;
+        
+        /* Pure virtual methods */
+        virtual TransferHelper *getHelper(
+                const std::vector<ProtocolHint *> &hints) const = 0;
+        virtual bool open() = 0;
+        virtual void close() = 0;
+
+    protected:
+        RS232 *rs232;
+        DeviceLocatorInterface *deviceLocator;
+    };
+
+}
+
+#endif /* RS232INTERFACE_H */

source/OSIF/include/common/buses/rs232/RS232TransferHelper.h

@@ -0,0 +1,65 @@
+/***************************************************//**
+ * @file    RS232TransferHelper.h
+ * @date    April 2011
+ * @author  Ocean Optics, Inc.
+ *
+ * This provides an abstraction around the RS232 bus.
+ * RS232 is pretty simple once the port is opened and
+ * configured, so this mostly just takes care of ensuring
+ * that all bytes are sent and received as required.
+ *
+ * This will effectively block on reads and writes until
+ * they are complete.  A non-blocking transfer helper
+ * could be created to complement this if there was
+ * some need, but it is not clear who would be responsible
+ * for delayed reads or retransmits.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef RS232TRANSFERHELPER_H
+#define RS232TRANSFERHELPER_H
+
+#include "common/buses/TransferHelper.h"
+#include "native/rs232/RS232.h"
+
+namespace seabreeze {
+
+    class RS232TransferHelper : public TransferHelper {
+    public:
+        RS232TransferHelper(RS232 *rs232Descriptor);
+        virtual ~RS232TransferHelper();
+
+        virtual int receive(std::vector<byte> &buffer, unsigned int length)
+            throw (BusTransferException);
+        virtual int send(const std::vector<byte> &buffer, unsigned int length) const
+            throw (BusTransferException);
+
+    protected:
+        RS232 *rs232;
+    };
+
+}
+
+#endif /* USBTRANSFERHELPER_H */

source/OSIF/include/common/buses/usb/USBDeviceLocator.h

@@ -0,0 +1,59 @@
+/***************************************************//**
+ * @file    USBDeviceLocator.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This class encapsulates the information needed to open
+ * a device on a USB bus.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef USBDEVICELOCATOR_H
+#define USBDEVICELOCATOR_H
+
+#include "common/buses/DeviceLocatorInterface.h"
+#include <string>
+
+namespace seabreeze {
+
+    class USBDeviceLocator : public DeviceLocatorInterface {
+    public:
+        USBDeviceLocator(unsigned long ID);
+        virtual ~USBDeviceLocator();
+
+        /* Inherited from DeviceLocatorInterface */
+        virtual unsigned long getUniqueLocation() const;
+        virtual bool equals(DeviceLocatorInterface &that);
+        virtual std::string getDescription();
+        virtual BusFamily getBusFamily() const;
+        virtual DeviceLocatorInterface *clone() const;
+
+    private:
+        unsigned long deviceID;
+    };
+
+}
+
+#endif /* USBDEVICELOCATOR_H */

source/OSIF/include/common/buses/usb/USBInterface.h

@@ -0,0 +1,64 @@
+/***************************************************//**
+ * @file    USBInterface.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is an abstract base class intended to be an interface
+ * for USB control objects.  This allows USB devices to
+ * be opened generically (just by providing the index of
+ * the device on the bus) without any concern for
+ * the vendor ID, product ID, or underlying USB implementation.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef USBINTERFACE_H
+#define USBINTERFACE_H
+
+#include "common/buses/Bus.h"
+#include "native/usb/NativeUSB.h"
+#include "native/usb/USB.h"
+#include "common/exceptions/IllegalArgumentException.h"
+
+namespace seabreeze {
+
+    class USBInterface : public Bus {
+    public:
+        USBInterface();
+        virtual ~USBInterface();
+        virtual USB *getUSBDescriptor() const;
+        virtual DeviceLocatorInterface *getLocation();
+        virtual void setLocation(const DeviceLocatorInterface &location) throw (IllegalArgumentException);
+        virtual BusFamily getBusFamily() const;
+        virtual bool open() = 0;
+        virtual void close() = 0;
+
+    protected:
+        USB *usb;
+        DeviceLocatorInterface *deviceLocator;
+    };
+
+}
+
+#endif /* USBINTERFACE_H */

source/OSIF/include/common/buses/usb/USBTransferHelper.h

@@ -0,0 +1,66 @@
+/***************************************************//**
+ * @file    USBTransferHelper.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a TransferHelper intended for USB communications.
+ * Each USBTransferHelper must specify a sending and
+ * receiving endpoint, which will tend to vary according to
+ * the type of data transfer being conducted.  This adapts
+ * the send() and receive() methods required of a TransferHelper
+ * according to a particular type of transfer, which may be
+ * inferred from a ProtocolHint.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef USBTRANSFERHELPER_H
+#define USBTRANSFERHELPER_H
+
+#include "common/buses/TransferHelper.h"
+#include "native/usb/USB.h"
+
+namespace seabreeze {
+
+    class USBTransferHelper : public TransferHelper {
+    public:
+        USBTransferHelper(USB *usbDescriptor, int sendEndpoint,
+                int receiveEndpoint);
+        USBTransferHelper(USB *usbDescriptor);
+        virtual ~USBTransferHelper();
+
+        virtual int receive(std::vector<byte> &buffer, unsigned int length)
+            throw (BusTransferException);
+        virtual int send(const std::vector<byte> &buffer, unsigned int length) const
+            throw (BusTransferException);
+
+    protected:
+        USB *usb;
+        int sendEndpoint;
+        int receiveEndpoint;
+    };
+
+}
+
+#endif /* USBTRANSFERHELPER_H */

source/OSIF/include/common/devices/Device.h

@@ -0,0 +1,129 @@
+/***************************************************//**
+ * @file    Device.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a base class for all sorts of devices.  A
+ * device is really just an aggregation of features
+ * with the protocols and buses required to access them.
+ * A Device is intended to represent a single discrete
+ * piece of equipment that may have several capabilities
+ * (features) inside.  The device may communicate to the
+ * outside world via seqences of bytes (a protocol) that
+ * are transferred across a physical medium (the bus).
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef DEVICE_H
+#define DEVICE_H
+
+#include <vector>
+#include <string>
+#include "common/buses/Bus.h"
+#include "common/buses/BusFamily.h"
+#include "common/buses/DeviceLocatorInterface.h"
+#include "common/features/Feature.h"
+#include "common/features/FeatureFamily.h"
+#include "common/protocols/Protocol.h"
+
+
+// usb endpoints are associated with a particular device.
+typedef enum usbEndpointType 
+{ 
+	kEndpointTypePrimaryOut, // slow speed
+	kEndpointTypePrimaryIn,  // slow speed
+	kEndpointTypeSecondaryOut, // could be high speed
+	kEndpointTypeSecondaryIn,  // could be high speed
+	kEndpointTypeSecondaryIn2  // generally high speed
+} usbEndpointType;
+        	
+namespace seabreeze {
+
+    class Device {
+    public:
+        Device();
+        virtual ~Device();
+        std::vector<Bus *> &getBuses();
+        std::vector<Feature *> &getFeatures();
+        std::vector<Protocol *> &getProtocols();
+        std::string &getName();
+        
+        // get the usb endpoints, according to the endpointType enumerator, 
+        //  if the endpoint type is not used, a 0 is returned
+        // TODO: this should be delegated down into a Bus instance
+        // (e.g. found by getBusesByFamily()) for USB.  It is inappropriate here.
+        unsigned char getEndpoint(int *errorCode, usbEndpointType endpointType);
+
+        /* This will allow the driver to probe the device and initialize itself
+         * based on what it finds there.  This should be called shortly after
+         * open().  The Device instance should use the indicated Bus instance to
+         * communicate with the hardware and get everything set up.  It can
+         * use any appropriate protocol or protocols that are valid for the Bus.
+         */
+        virtual bool initialize(const Bus &bus);
+
+        /* Each instance of a device is assumed to be associated with a unique
+         * location on a bus.  If the device is connected via multiple buses, then
+         * a special DeviceLocator and TransferHelper will have to hide those
+         * details.  Otherwise, each connection to the device will be considered
+         * independent of all others.
+         */
+        virtual DeviceLocatorInterface *getLocation();
+        virtual void setLocation(const DeviceLocatorInterface &loc);
+
+        virtual int open();
+
+        virtual void close();
+
+        virtual std::vector<Bus *> getBusesByFamily(BusFamily &family);
+
+        virtual seabreeze::ProtocolFamily getSupportedProtocol(
+                seabreeze::FeatureFamily family, BusFamily bus) = 0;
+
+        virtual std::vector<Protocol *> getProtocolsByFamily(
+                seabreeze::ProtocolFamily &family);
+
+        virtual Bus *getOpenedBus();
+
+    protected:
+        std::vector<Bus *> buses;
+        std::vector<Feature *> features;
+        std::vector<Protocol *> protocols;
+
+        std::string name;
+        unsigned char usbEndpoint_primary_out;
+    	unsigned char usbEndpoint_primary_in;
+    	unsigned char usbEndpoint_secondary_out;
+    	unsigned char usbEndpoint_secondary_in;
+    	unsigned char usbEndpoint_secondary_in2; 
+    	
+
+        DeviceLocatorInterface *location;
+        Bus *openedBus;
+    };
+
+}
+
+#endif /* DEVICE_H */

source/OSIF/include/common/exceptions/BusConnectException.h

@@ -0,0 +1,49 @@
+/***************************************************//**
+ * @file    BusConnectException.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This exception should be used when an error is
+ * encountered when trying to connect to a bus,
+ * generally a failed open() or socket connect() call, or
+ * a failed read() or write() due to an EOF.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef BUSCONNECTEXCEPTION_H
+#define BUSCONNECTEXCEPTION_H
+
+#include "common/exceptions/BusException.h"
+
+namespace seabreeze {
+
+    class BusConnectException : public BusException {
+    public:
+        BusConnectException(const std::string &error);
+    };
+
+}
+
+#endif /* BUSCONNECTEXCEPTION_H */

source/OSIF/include/common/exceptions/BusException.h

@@ -0,0 +1,50 @@
+/***************************************************//**
+ * @file    BusException.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a base class for a family of exceptions that
+ * arise from errors in bus transfers.  These may be thrown
+ * at the bus layer, and all exceptions thrown at
+ * that layer must extend this class so that they can be
+ * uniformly handled.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_BUSEXCEPTION_H
+#define SEABREEZE_BUSEXCEPTION_H
+
+#include <stdexcept>
+
+namespace seabreeze {
+
+    class BusException : public std::runtime_error {
+    public:
+        BusException(const std::string &error);
+    };
+
+}
+
+#endif

source/OSIF/include/common/exceptions/BusTransferException.h

@@ -0,0 +1,48 @@
+/***************************************************//**
+ * @file    BusTransferException.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This exception should be used when an error is
+ * encountered when trying to read from or write to
+ * a bus.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef BUSTRANSFEREXCEPTION_H
+#define BUSTRANSFEREXCEPTION_H
+
+#include "common/exceptions/BusException.h"
+
+namespace seabreeze {
+
+    class BusTransferException : public BusException {
+    public:
+        BusTransferException(const std::string &error);
+    };
+
+}
+
+#endif /* BUSTRANSFEREXCEPTION_H */

source/OSIF/include/common/exceptions/FeatureControlException.h

@@ -0,0 +1,47 @@
+/***************************************************//**
+ * @file    FeatureControlException.h
+ * @date    March 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This exception should be used when an error is
+ * encountered when trying to interact with a feature.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef FEATURECONTROLEXCEPTION_H
+#define FEATURECONTROLEXCEPTION_H
+
+#include "common/exceptions/FeatureException.h"
+
+namespace seabreeze {
+
+    class FeatureControlException : public FeatureException {
+    public:
+        FeatureControlException(const std::string &error);
+    };
+
+}
+
+#endif /* FEATURECONTROLEXCEPTION_H */

source/OSIF/include/common/exceptions/FeatureException.h

@@ -0,0 +1,50 @@
+/***************************************************//**
+ * @file    FeatureException.h
+ * @date    March 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a base class for a family of exceptions that
+ * arise from errors in feature interaction.  These may be thrown
+ * at the feature layer, and all exceptions thrown at
+ * that layer must extend this class so that they can be
+ * uniformly handled.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_FEATUREEXCEPTION_H
+#define SEABREEZE_FEATUREEXCEPTION_H
+
+#include <stdexcept>
+
+namespace seabreeze {
+
+    class FeatureException : public std::runtime_error {
+    public:
+        FeatureException(const std::string &error);
+    };
+
+}
+
+#endif

source/OSIF/include/common/exceptions/FeatureProtocolNotFoundException.h

@@ -0,0 +1,48 @@
+/***************************************************//**
+ * @file    FeatureProtocolNotFoundException.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This exception should be used when a protocol is
+ * specified, but no matching implementation of that
+ * protocol can be found for a particular feature.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef FEATUREPROTOCOLNOTFOUNDEXCEPTION_H
+#define FEATUREPROTOCOLNOTFOUNDEXCEPTION_H
+
+#include "common/exceptions/FeatureException.h"
+
+namespace seabreeze {
+
+    class FeatureProtocolNotFoundException : public FeatureException {
+    public:
+        FeatureProtocolNotFoundException(const std::string &error);
+    };
+
+}
+
+#endif /* FEATUREPROTOCOLNOTFOUNDEXCEPTION_H */

source/OSIF/include/common/exceptions/IllegalArgumentException.h

@@ -0,0 +1,50 @@
+/***************************************************//**
+ * @file    IllegalArgumentException.h
+ * @date    March 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is an exception for use when a value is passed to
+ * a method that is not permitted.  This may include
+ * specifying a parameter that is out of bounds or of
+ * the wrong type.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_ILLEGALARGUMENTEXCEPTION_H
+#define SEABREEZE_ILLEGALARGUMENTEXCEPTION_H
+
+#include <stdexcept>
+#include <string>
+
+namespace seabreeze {
+
+    class IllegalArgumentException : public std::invalid_argument {
+    public:
+        IllegalArgumentException(const std::string &error);
+    };
+
+}
+
+#endif

source/OSIF/include/common/exceptions/NumberFormatException.h

@@ -0,0 +1,49 @@
+/***************************************************//**
+ * @file    NumberFormatException.h
+ * @date    March 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is an exception for use when a string is to be
+ * parsed into a number but the string does not contain
+ * a recognizable number.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_NUMBERFORMATEXCEPTION_H
+#define SEABREEZE_NUMBERFORMATEXCEPTION_H
+
+#include <stdexcept>
+#include <string>
+
+namespace seabreeze {
+
+    class NumberFormatException : public std::runtime_error {
+    public:
+        NumberFormatException(const std::string &error);
+    };
+
+}
+
+#endif

source/OSIF/include/common/exceptions/ProtocolBusMismatchException.h

@@ -0,0 +1,49 @@
+/***************************************************//**
+ * @file    ProtocolBusMismatchException.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This exception should be used when a protocol is
+ * specified, but the bus and protocol are not suited to
+ * each other (e.g. there is no bus helper for the hints
+ * the protocol can provide).
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef PROTOCOLBUSMISMATCHEXCEPTION_H
+#define PROTOCOLBUSMISMATCHEXCEPTION_H
+
+#include "common/exceptions/ProtocolException.h"
+
+namespace seabreeze {
+
+    class ProtocolBusMismatchException : public ProtocolException {
+    public:
+        ProtocolBusMismatchException(const std::string &error);
+    };
+
+}
+
+#endif /* PROTOCOLBUSMISMATCHEXCEPTION_H */

source/OSIF/include/common/exceptions/ProtocolException.h

@@ -0,0 +1,51 @@
+/***************************************************//**
+ * @file    ProtocolException.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a base class for a family of exceptions that
+ * arise from errors in protocols.  These may be thrown
+ * at the protocol layer, and all exceptions thrown at
+ * that layer must extend this class so that they can be
+ * uniformly handled.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_PROTOCOLEXCEPTION_H
+#define SEABREEZE_PROTOCOLEXCEPTION_H
+
+#include <stdexcept>
+#include <string>
+
+namespace seabreeze {
+
+    class ProtocolException : public std::runtime_error {
+    public:
+        ProtocolException(const std::string &error);
+    };
+
+}
+
+#endif

source/OSIF/include/common/exceptions/ProtocolFormatException.h

@@ -0,0 +1,50 @@
+/***************************************************//**
+ * @file    ProtocolFormatException.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This exception should be used when a protocol message
+ * cannot be decoded, fails a checksum, or otherwise is
+ * out of spec.  This may indicate that the driver is now
+ * out of synch with this code and that measures should be
+ * taken to re-establish communications.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef PROTOCOLFORMATEXCEPTION_H
+#define PROTOCOLFORMATEXCEPTION_H
+
+#include "common/exceptions/ProtocolException.h"
+
+namespace seabreeze {
+
+    class ProtocolFormatException : public ProtocolException {
+    public:
+        ProtocolFormatException(const std::string &error);
+    };
+
+}
+
+#endif /* PROTOCOLFORMATEXCEPTION_H */

source/OSIF/include/common/exceptions/ProtocolTransactionException.h

@@ -0,0 +1,51 @@
+/***************************************************//**
+ * @file    ProtocolTransactionException.h
+ * @date    January 2015
+ * @author  Ocean Optics, Inc., Kirk Clendinning, Heliospectra
+ *
+ * This is a base class for a family of exceptions that
+ * arise from errors in during OBPTransactions.  These may be thrown
+ * at the protocol layer, and all exceptions thrown at
+ * that layer must extend this class so that they can be
+ * uniformly handled.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_PROTOCOLTRANSACTIONEXCEPTION_H
+#define SEABREEZE_PROTOCOLTRANSACTIONEXCEPTION_H
+
+#include <stdexcept>
+#include <string>
+
+namespace seabreeze {
+
+    class ProtocolTransactionException : public std::runtime_error {
+    public:
+        ProtocolTransactionException(const std::string &error);
+    };
+
+}
+
+#endif

source/OSIF/include/common/features/Feature.h

@@ -0,0 +1,71 @@
+/***************************************************//**
+ * @file    Feature.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is an abstract interface that other feature types will
+ * implement.  A Feature is taken to be some capability of
+ * a Device that is relatively self-contained.  For instance,
+ * an analog output voltage would be a Feature.  Features can
+ * also contain multiple functions; for instance, a TEC may
+ * be able to report a temperature, take a temperature as a
+ * set point, and turn on or off.  These capabilities are
+ * interrelated, and would be considered a single feature.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef FEATURE_H
+#define FEATURE_H
+
+#include "common/SeaBreeze.h"
+#include "common/buses/Bus.h"
+#include "common/features/FeatureFamily.h"
+#include "common/exceptions/FeatureException.h"
+#include "common/protocols/Protocol.h"
+#include <vector>
+
+namespace seabreeze {
+
+    class Feature {
+    public:
+        virtual ~Feature() = 0;
+
+        /* Allow the object that represents a given feature to initialize
+         * itself by reading from the corresponding feature on the real
+         * device, and/or put the real device feature into a known state.
+         * This should return true if the feature is ready to be used, and false
+         * otherwise.
+         */
+        virtual bool initialize(const Protocol &protocol, const Bus &bus)
+            throw (FeatureException) = 0;
+
+        virtual FeatureFamily getFeatureFamily() = 0;
+    };
+
+    /* Default implementation for (otherwise) pure virtual destructor */
+    inline Feature::~Feature() {}
+}
+
+#endif /* FEATURE_H */

source/OSIF/include/common/features/FeatureFamily.h

@@ -0,0 +1,56 @@
+/***************************************************//**
+ * @file    FeatureFamily.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This provides a way to describe different kinds
+ * features (e.g. spectrometer, TEC) generically.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_FEATUREFAMILY_H
+#define SEABREEZE_FEATUREFAMILY_H
+
+#include <string>
+
+namespace seabreeze {
+    class FeatureFamily {
+    public:
+        FeatureFamily();
+        virtual ~FeatureFamily();
+        virtual std::string getName();
+        virtual bool equals(const FeatureFamily &that);
+        virtual unsigned short getType();
+
+    protected:
+        FeatureFamily(std::string name, unsigned short id);
+
+    private:
+        std::string featureName;
+        unsigned short type;
+    };
+}
+
+#endif

source/OSIF/include/common/features/FeatureImpl.h

@@ -0,0 +1,88 @@
+/***************************************************//**
+ * @file    FeatureImpl.h
+ * @date    March 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a simple base class that other feature types will
+ * extend.  A Feature is taken to be some capability of
+ * a Device that is relatively self-contained.  For instance,
+ * an analog output voltage would be a Feature.  Features can
+ * also contain multiple functions; for instance, a TEC may
+ * be able to report a temperature, take a temperature as a
+ * set point, and turn on or off.  These capabilities are
+ * interrelated, and would be considered a single feature.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef FEATUREIMPL_H
+#define FEATUREIMPL_H
+
+#include "common/SeaBreeze.h"
+#include "common/exceptions/FeatureProtocolNotFoundException.h"
+#include "common/features/Feature.h"
+#include "common/protocols/ProtocolHelper.h"
+#include <vector>
+
+namespace seabreeze {
+    /* This does virtual inheritance from Feature because it is assumed that
+     * in some cases there will be diamond inheritance.  This will generally
+     * only happen where one top-level Feature is implemented by deriving from
+     * another Feature.
+     */
+    class FeatureImpl : public virtual Feature {
+    public:
+        FeatureImpl();
+        virtual ~FeatureImpl();
+
+        /* Allow the object that represents a given feature to initialize
+         * itself by reading from the corresponding feature on the real
+         * device, and/or put the real device feature into a known state.
+         * Overriding this is not required.  This should return true if
+         * the feature is ready to be used, and false otherwise.
+         */
+        virtual bool initialize(const Protocol &protocol, const Bus &bus)
+            throw (FeatureException);
+
+        virtual FeatureFamily getFeatureFamily() = 0;
+
+    protected:
+        std::vector<ProtocolHelper *> protocols;
+
+        /* Protocols are described by their base class (Protocol)
+         * and may be designated that way.  However, different
+         * functionality within a given command set may be broken
+         * into different implementation types, all of which extend
+         * the base Protocol class.  This is a simple lookup mechanism
+         * to use the Protocol that some anonymous caller might
+         * provide as a point of reference to then find the extended
+         * Protocol class that can be used to access certain features.
+         */
+        ProtocolHelper *lookupProtocolImpl(const Protocol &protocol)
+                        throw (FeatureProtocolNotFoundException);
+    };
+
+}
+
+#endif /* FEATUREIMPL_H */

source/OSIF/include/common/globals.h

@@ -0,0 +1,65 @@
+/**
+* @file     globals.h
+* @author   Mark Zieg <mark.zieg@oceanoptics.com>
+* @date     Sep 26, 2012
+* @brief    Provides a single point of maintenance for anything you want
+*           included, defined, or set across every file in the application
+*           (such as memory profiling, etc).  Normally empty.
+*
+* LICENSE:
+*
+* SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject
+* to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included
+* in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef SEABREEZE_GLOBALS_H
+#define SEABREEZE_GLOBALS_H
+
+// change to "#if 1" to enable memory heap debugging under Visual Studio
+#if 0
+    #ifdef _WINDOWS
+
+        // For these to work right, you need to #define _CRTDBG_MAP_ALLOC and
+        // _CRTDBG_MAP_ALLOC_NEW in your Visual Studio project (i.e., Project
+        // -> Configuration Properties -> C/C++ -> Preprocessor -> Preprocessor
+        // Definitions).  #Defining them here in your header files DOES NOT
+        // WORK, because Visual Studio will internally include many system
+        // headers (including stdafx.h) long before you get here.
+        //
+        // @see http://msdn.microsoft.com/en-us/library/e5ewb1h3%28v=vs.80%29.aspx
+        // @see http://social.msdn.microsoft.com/Forums/en/vcgeneral/thread/ebc7dd7a-f3c6-49f1-8a60-e381052f21b6,
+
+        #pragma message("  (Windows memory debugging enabled)")
+
+        // these will provide leak profiling for C malloc(), etc
+        #include <stdlib.h>
+        #include <crtdbg.h>
+
+        // these will provide leak profiling for C++ 'new'
+        #ifndef DBG_NEW
+            #define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
+            #define new DBG_NEW
+        #endif
+
+    #endif
+#endif
+
+#endif

source/OSIF/include/common/protocols/Exchange.h

@@ -0,0 +1,59 @@
+/***************************************************//**
+ * @file    Exchange.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is simply an interface that other classes will
+ * extend to have a common transfer() and getHints methods
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_EXCHANGE_H
+#define SEABREEZE_EXCHANGE_H
+
+#include <vector>
+#include "common/buses/TransferHelper.h"
+#include "common/protocols/ProtocolHint.h"
+#include "common/Data.h"
+#include "common/exceptions/ProtocolException.h"
+
+namespace seabreeze {
+
+    class Exchange {
+    public:
+        Exchange();
+        Exchange(std::vector<ProtocolHint *> *hints);
+        virtual ~Exchange();
+        virtual Data *transfer(TransferHelper *helper) throw (ProtocolException) = 0;
+        virtual const std::vector<ProtocolHint *> &getHints();
+
+    protected:
+        std::vector<ProtocolHint *> *hints;
+    };
+
+}
+
+#endif /* SEABREEZE_EXCHANGE_H */
+

source/OSIF/include/common/protocols/Protocol.h

@@ -0,0 +1,62 @@
+/***************************************************//**
+ * @file    Protocol.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * This is a simple identifier cookie that will allow two
+ * objects to agree on whether they support a given command
+ * set (protocol).  Each will hold Protocol objects that they
+ * can then compare to see if they agree.  This allows a loose
+ * binding between sets of Exchanges (elsewhere called protocols)
+ * and buses.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_PROTOCOL_H
+#define SEABREEZE_PROTOCOL_H
+
+#include "common/protocols/ProtocolFamily.h"
+
+namespace seabreeze {
+
+    class Protocol {
+    public:
+        Protocol(int id);
+        /* Copy constructor */
+        Protocol(Protocol const &that);
+        virtual ~Protocol();
+        bool equals(Protocol const &that);
+
+        virtual ProtocolFamily getProtocolFamily() = 0;
+
+    protected:
+        /* Protected for derived classes to use. */
+        Protocol();
+        int id;
+    };
+
+}
+
+#endif

source/OSIF/include/common/protocols/ProtocolFamily.h

@@ -0,0 +1,55 @@
+/***************************************************//**
+ * @file    ProtocolFamily.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This provides a way to describe different kinds
+ * protocols (e.g. OOI, OBP) generically.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_PROTOCOLFAMILY_H
+#define SEABREEZE_PROTOCOLFAMILY_H
+
+#include <string>
+
+namespace seabreeze {
+    class ProtocolFamily {
+    public:
+        virtual ~ProtocolFamily();
+        virtual std::string getName();
+        virtual bool equals(const ProtocolFamily &that);
+        virtual unsigned short getType();
+
+    protected:
+        ProtocolFamily(std::string name, unsigned short id);
+
+    private:
+        std::string protocolName;
+        unsigned short type;
+    };
+}
+
+#endif

source/OSIF/include/common/protocols/ProtocolHelper.h

@@ -0,0 +1,60 @@
+/***************************************************//**
+ * @file    ProtocolHelper.h
+ * @date    July 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * Feature instances may look up an implementation object
+ * that matches a particular Protocol.  All such implementations
+ * should in some way derive from ProtocolHelper so that
+ * Feature's look up mechanism can return them.  It is
+ * expected that each Feature will have a corresponding
+ * interface at the Protocol layer; those interface classes
+ * should derive from this class, and their implementations
+ * will thus extend this as well.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_PROTOCOLHELPER_H
+#define SEABREEZE_PROTOCOLHELPER_H
+
+#include "common/protocols/Protocol.h"
+
+namespace seabreeze {
+
+    class ProtocolHelper {
+    public:
+        ProtocolHelper(Protocol *proto);
+        virtual ~ProtocolHelper();
+        Protocol &getProtocol();
+
+    protected:
+        /* Protected for derived classes to use. */
+        ProtocolHelper();
+        Protocol *protocol;
+    };
+
+}
+
+#endif

source/OSIF/include/common/protocols/ProtocolHint.h

@@ -0,0 +1,73 @@
+/***************************************************//**
+ * @file    ProtocolHint.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * Hints are used to identify particular characteristics about
+ * protocol Transfer objects.  A hint may be used to indicate
+ * to a bus some detail it needs about making a transfer, e.g.
+ * what endpoint would be appropriate for USB.  Note that the
+ * bus (or its helpers) are under no obligation to respect hints.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_PROTOCOLHINT_H
+#define SEABREEZE_PROTOCOLHINT_H
+
+#include "common/SeaBreeze.h"
+#include <string>
+
+namespace seabreeze {
+
+    class ProtocolHint {
+    public:
+        ProtocolHint(int id, std::string desc);
+
+        /* For derived classes that will fill in their own values
+         * and for containers to be able to initialize themselves.
+         * This does not set any meaningful values and should not be
+         * relied on to create a proper instance.
+         */
+        ProtocolHint();
+
+        virtual ~ProtocolHint();
+        std::string getDescription();
+        int getID() const;
+
+        /* Overloading the equality operator so that this can be
+         * used as a key for hash_map associations without the actual
+         * key objects having to be identical.
+         */
+        bool operator==(const ProtocolHint &that);
+
+    protected:
+        int id;
+        std::string description;
+    };
+
+}
+
+#endif /* SEABREEZE_PROTOCOLHINT_H */
+

source/OSIF/include/common/protocols/Transaction.h

@@ -0,0 +1,82 @@
+/***************************************************//**
+ * @file    Transaction.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * The Transaction class is simply a wrapper
+ * around one or more Transfer objects that must
+ * be executed in a particular order.  This is
+ * provided for convenience.  Some transfers
+ * to Ocean Optics spectrometers put the spectrometer
+ * into a particular state where it expects another
+ * action to be taken, and Transaction objects can
+ * be used to ensure that all expected operations occur.
+ *
+ * Some actions, like requesting a spectrum, do not
+ * necessarily require that the next action be a read
+ * operation.  Thus, some Transfers that appear to follow
+ * a causal chain may not in fact make good Transactions.
+ * In this case, reading the status of the device until
+ * it reports data ready is a common operation before
+ * reading the spectrum.
+ *
+ * Note that the Transaction class has no notion of buses
+ * or protocols, and this is by design.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_TRANSACTION_H
+#define SEABREEZE_TRANSACTION_H
+
+#include <vector>
+#include "common/protocols/Exchange.h"
+#include "common/protocols/Transfer.h"
+#include "common/buses/TransferHelper.h"
+#include "common/protocols/ProtocolHint.h"
+#include "common/Data.h"
+
+namespace seabreeze {
+
+    class Transaction : public Exchange {
+    public:
+        Transaction();
+        virtual ~Transaction();
+        void addTransfer(Transfer *xfer);
+
+        /* Inherited from Exchange */
+        virtual Data *transfer(TransferHelper *helper) throw (ProtocolException);
+
+    protected:
+        std::vector<Transfer *> transfers;
+
+    private:
+        void updateHints();
+
+    };
+
+}
+
+#endif /* SEABREEZE_TRANSACTION_H */
+

source/OSIF/include/common/protocols/Transfer.h

@@ -0,0 +1,93 @@
+/***************************************************//**
+ * @file    Transfer.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * The Transfer class captures a simplex
+ * data transfer to or from a device.  At this
+ * level, there is no notion of a particular bus,
+ * just data, length, and direction.
+ *
+ * The bus aspects are encapsulated in a "helper"
+ * object that must be provided when the Transfer
+ * is executed.  The helper must provide send() and
+ * receive() methods taking a buffer and length
+ * only.  All of the details in getting the transfer to
+ * or from the other end must be handled by the helper.
+ * The helper is expected to be created by some aspect
+ * of the driver for the device in question.  It contains
+ * information about the connection and the particulars
+ * about routing data in and out.
+ *
+ * Note that the Transfer class is completely orthagonal to any
+ * particular protocol.  It is expected that a protocol may be
+ * built up as a collection of related Transfer types.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_TRANSFER_H
+#define SEABREEZE_TRANSFER_H
+
+#include <vector>
+#include "common/protocols/Exchange.h"
+#include "common/protocols/ProtocolHint.h"
+#include "common/Data.h"
+
+typedef unsigned int direction_t;
+
+namespace seabreeze {
+
+    class Transfer : public Exchange {
+    public:
+
+        /* Note that the size of the provided buffer and the specified length
+         * of the transfer itself do not need to agree.  If the transfer requires
+         * more space than the buffer provides, the buffer will be resized.
+         * If the buffer is created larger than is needed, only the given length
+         * will be sent or received.  This allows for some freedom in buffer
+         * management.
+         */
+        Transfer(std::vector<ProtocolHint *> *hints, std::vector<byte> *buffer,
+                direction_t direction, unsigned int length);
+
+        virtual ~Transfer();
+        virtual Data *transfer(TransferHelper *helper) throw (ProtocolException);
+
+        static const direction_t TO_DEVICE;
+        static const direction_t FROM_DEVICE;
+
+    protected:
+        Transfer();
+        void checkBufferSize();
+
+        unsigned int length;
+        std::vector<byte> *buffer;
+        direction_t direction;
+    };
+
+}
+
+#endif /* SEABREEZE_TRANSFER_H */
+

source/OSIF/include/native/network/Inet4Address.h

@@ -0,0 +1,62 @@
+/***************************************************//**
+ * @file    Inet4Address.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_INET4ADDRESS_H
+#define SEABREEZE_INET4ADDRESS_H
+
+#include <string>
+#include "common/exceptions/IllegalArgumentException.h"
+#include "common/SeaBreeze.h"
+
+#ifdef _WINDOWS
+#include <winsock2.h>
+#else
+#include <netinet/in.h>
+#endif
+
+namespace seabreeze {
+    class Inet4Address {
+    public:
+        Inet4Address();
+        Inet4Address(std::string ipAddressQuads)
+            throw (IllegalArgumentException);
+        Inet4Address(struct in_addr *ipAddr);
+        Inet4Address(const Inet4Address &that);
+        ~Inet4Address();
+        
+        struct in_addr getAddress();
+        
+        std::string getHostAddress();
+        
+    private:
+        struct in_addr in;
+    };
+}
+
+#endif /* SEABREEZE_INET4ADDRESS_H */

source/OSIF/include/native/network/Socket.h

@@ -0,0 +1,80 @@
+/***************************************************//**
+ * @file    Socket.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_SOCKET_H
+#define SEABREEZE_SOCKET_H
+
+/* Includes */
+#include "common/SeaBreeze.h"
+#include "common/exceptions/BusTransferException.h"
+#include "common/exceptions/BusConnectException.h"
+#include "native/network/SocketException.h"
+#include "native/network/UnknownHostException.h"
+#include "native/network/Inet4Address.h"
+#include <string>
+
+namespace seabreeze {
+    
+    class Socket {
+    public:
+        static Socket *create();
+        
+        virtual ~Socket();
+        
+        virtual void connect(Inet4Address &addr, int port)
+                throw (UnknownHostException, BusConnectException) = 0;
+        virtual void connect(const std::string host, int port)
+                throw (UnknownHostException, BusConnectException) = 0;
+        
+        virtual void close() throw (BusException) = 0;
+        virtual bool isClosed() = 0;
+        virtual bool isBound() = 0;
+        
+        /* Socket options */
+        virtual int getSOLinger() throw (SocketException) = 0;
+        virtual void setSOLinger(bool enable, int linger)
+            throw (SocketException) = 0;
+        virtual unsigned long getReadTimeoutMillis()
+            throw (SocketException) = 0;
+        virtual void setReadTimeoutMillis(unsigned long timeout)
+            throw (SocketException) = 0;
+        
+        /* Data transfer */
+        virtual int read(unsigned char *buffer, unsigned long length)
+            throw (BusTransferException) = 0;
+        virtual int write(const unsigned char *buffer, unsigned long length)
+            throw (BusTransferException) = 0;
+        
+    };
+    
+    /* Default implementation for (otherwise) pure virtual destructor */
+    inline Socket::~Socket() {}
+}
+
+#endif /* SEABREEZE_SOCKET_H */

source/OSIF/include/native/network/SocketException.h

@@ -0,0 +1,44 @@
+/***************************************************//**
+ * @file    SocketException.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_SOCKETEXCEPTION_H
+#define SEABREEZE_SOCKETEXCEPTION_H
+
+#include "common/exceptions/BusException.h"
+
+namespace seabreeze {
+
+    class SocketException : public BusException {
+    public:
+        SocketException(const std::string &error);
+    };
+
+}
+
+#endif /* SEABREEZE_SOCKETEXCEPTION_H */

source/OSIF/include/native/network/SocketTimeoutException.h

@@ -0,0 +1,45 @@
+/***************************************************//**
+ * @file    SocketTimeoutException.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+
+#ifndef SEABREEZE_SOCKETTIMEOUTEXCEPTION_H
+#define SEABREEZE_SOCKETTIMEOUTEXCEPTION_H
+
+#include "native/network/SocketException.h"
+
+namespace seabreeze {
+
+    class SocketTimeoutException : public SocketException {
+    public:
+        SocketTimeoutException(const std::string &error);
+    };
+
+}
+
+#endif /* SEABREEZE_SOCKETTIMEOUTEXCEPTION_H */

source/OSIF/include/native/network/UnknownHostException.h

@@ -0,0 +1,44 @@
+/***************************************************//**
+ * @file    UnknownHostException.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_UNKNOWNHOSTEXCEPTION_H
+#define SEABREEZE_UNKNOWNHOSTEXCEPTION_H
+
+#include <stdexcept>
+
+namespace seabreeze {
+
+    class UnknownHostException : public std::runtime_error {
+    public:
+        UnknownHostException(const std::string &error);
+    };
+
+}
+
+#endif /* SEABREEZE_UNKNOWNHOSTEXCEPTION_H */

source/OSIF/include/native/network/posix/NativeSocketPOSIX.h

@@ -0,0 +1,71 @@
+/***************************************************//**
+ * @file    NativeSocketPOSIX.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_NATIVESOCKETPOSIX_H
+#define SEABREEZE_NATIVESOCKETPOSIX_H
+
+#include "native/network/Socket.h"
+#include "native/network/Inet4Address.h"
+#include "common/exceptions/BusConnectException.h"
+#include <string>
+
+namespace seabreeze {
+    class NativeSocketPOSIX : public Socket {
+    public:
+        NativeSocketPOSIX();
+        virtual ~NativeSocketPOSIX();
+        
+        virtual void connect(Inet4Address &addr, int port)
+                throw (UnknownHostException, BusConnectException);
+        virtual void connect(const std::string hostname, int port)
+                throw (UnknownHostException, BusConnectException);
+        
+        virtual void close() throw (BusException);
+        virtual bool isClosed();
+        virtual bool isBound();
+        
+        virtual int getSOLinger() throw (SocketException);
+        virtual void setSOLinger(bool enable, int linger) throw (SocketException);
+        virtual unsigned long getReadTimeoutMillis() throw (SocketException);
+        virtual void setReadTimeoutMillis(unsigned long timeout) throw (SocketException);
+        
+        virtual int read(unsigned char *buffer, unsigned long length)
+            throw (BusTransferException);
+        virtual int write(const unsigned char *buffer, unsigned long length)
+            throw (BusTransferException);
+        
+    private:
+        int sock;
+        bool bound;
+        bool closed;
+        Inet4Address address;
+    };
+}
+
+#endif /* SEABREEZE_NATIVESOCKETPOSIX_H */

source/OSIF/include/native/network/windows/NativeSocketWindows.h

@@ -0,0 +1,73 @@
+/***************************************************//**
+ * @file    NativeSocketWindows.h
+ * @date    February 2016
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2016, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_NATIVESOCKETWINDOWS_H
+#define SEABREEZE_NATIVESOCKETWINDOWS_H
+
+#include "common/SeaBreeze.h"
+#include "native/network/Socket.h"
+#include "native/network/Inet4Address.h"
+#include "common/exceptions/BusConnectException.h"
+#include <Winsock2.h>
+#include <string>
+
+namespace seabreeze {
+    class NativeSocketWindows : public Socket {
+    public:
+        NativeSocketWindows();
+        virtual ~NativeSocketWindows();
+        
+        virtual void connect(Inet4Address &addr, int port)
+                throw (UnknownHostException, BusConnectException);
+        virtual void connect(const std::string hostname, int port)
+                throw (UnknownHostException, BusConnectException);
+        
+        virtual void close() throw (BusException);
+        virtual bool isClosed();
+        virtual bool isBound();
+        
+        virtual int getSOLinger() throw (SocketException);
+        virtual void setSOLinger(bool enable, int linger) throw (SocketException);
+        virtual unsigned long getReadTimeoutMillis() throw (SocketException);
+        virtual void setReadTimeoutMillis(unsigned long timeout) throw (SocketException);
+        
+        virtual int read(unsigned char *buffer, unsigned long length)
+            throw (BusTransferException);
+        virtual int write(const unsigned char *buffer, unsigned long length)
+            throw (BusTransferException);
+        
+    private:
+        SOCKET sock;
+        bool bound;
+        bool closed;
+        Inet4Address address;
+    };
+}
+
+#endif /* SEABREEZE_NATIVESOCKETWINDOWS_H */

source/OSIF/include/native/rs232/NativeRS232.h

@@ -0,0 +1,61 @@
+/***************************************************//**
+ * @file    NativeRS232.h
+ * @date    April 21, 2011
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ******************************************************/
+
+#ifndef NATIVERS232_H
+#define NATIVERS232_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define OPEN_OK 0
+#define NO_DEVICE_FOUND -1
+
+void *RS232Open(char *device, int *errorCode);
+
+int RS232Close(void *handle);
+
+int RS232Write(void *handle, char *data, int numberOfBytes);
+
+int RS232Read(void *handle, char *buffer, int numberOfBytes);
+
+int RS232SetBaudRate(void *handle, int rate);
+
+int RS232ClearInputBuffer(void *handle);
+
+int RS232ClearOutputBuffer(void *handle);
+
+int RS232WaitForWrite(void *handle);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* NATIVERS232_H */

source/OSIF/include/native/rs232/RS232.h

@@ -0,0 +1,66 @@
+/***************************************************//**
+ * @file    RS232.h
+ * @date    April 2011
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_RS232_H
+#define SEABREEZE_RS232_H
+
+#include "native/rs232/NativeRS232.h"
+
+namespace seabreeze {
+
+    class RS232 {
+    public:
+        RS232(const char *devicePath, int baudRate);
+        virtual ~RS232();
+
+        bool open();
+        bool close();
+        int write(void *data, unsigned int length_bytes);
+        int read(void *data, unsigned int length_bytes);
+
+        void setVerbose(bool v);
+        bool isOpened();
+
+    protected:
+
+        /* These methods are primarily for debugging. */
+        void rs232HexDump(void *x, int length, bool out);
+        void hexDump(void *x, int length);
+        void describeTransfer(int length, bool out);
+
+        void *descriptor;
+        bool opened;
+        bool verbose;
+        char *devicePath;
+        int baudRate;
+    };
+
+}
+
+#endif

source/OSIF/include/native/rs232/windows/NativeRS232Windows.h

@@ -0,0 +1,55 @@
+/***************************************************//**
+ * @file    NativeRS232Windows.h
+ * @date    April 21, 2011
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ******************************************************/
+
+#ifndef NATIVERS232WINDOWS_H
+#define NATIVERS232WINDOWS_H
+
+#ifndef _CRT_SECURE_NO_DEPRECATE
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include <string.h>
+#include <windows.h>
+#include <stdio.h>
+
+#ifndef INVALID_HANDLE_VALUE
+#define INVALID_HANDLE_VALUE (-1)
+#endif
+
+#ifdef __BORLANDC__
+#define EXPORTED __declspec(dllexport) __stdcall
+#else
+#define EXPORTED __declspec(dllexport)
+#endif /* __BORLANDC__ */
+#define int64 __int64
+
+#endif /* NATIVERS232WINDOWS_H */

source/OSIF/include/native/system/NativeSystem.h

@@ -0,0 +1,53 @@
+/***************************************************//**
+ * @file    NativeSystem.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * This file has declarations for the native C functions
+ * needed to access certain non-portable system calls.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+#ifndef NATIVE_SYSTEM_H
+#define NATIVE_SYSTEM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Native C prototypes */
+
+void sleepMilliseconds(unsigned int msecs);
+int systemInitialize();
+void systemShutdown();
+
+/* End of C prototypes */
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* NATIVE_SYSTEM_H */

source/OSIF/include/native/system/System.h

@@ -0,0 +1,51 @@
+/***************************************************//**
+ * @file    System.h
+ * @date    February 2012
+ * @author  Ocean Optics, Inc.
+ *
+ * The System class provides an abstract interface to
+ * certain system calls.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_SYSTEM_H
+#define SEABREEZE_SYSTEM_H
+
+namespace seabreeze {
+
+    class System {
+    public:
+        System();
+        virtual ~System();
+
+        static void sleepMilliseconds(unsigned int millis);
+        static bool initialize();
+        static void shutdown();
+
+    };
+
+}
+
+#endif

source/OSIF/include/native/usb/NativeUSB.h

@@ -0,0 +1,226 @@
+/***************************************************//**
+ * @file    NativeUSB.h
+ * @date    October 31, 2007
+ * @author  Ocean Optics, Inc.
+ *
+ * This provides a relatively simple interface for
+ * opening, closing, writing to, and reading from Ocean
+ * Optics USB Devices.  It has been extended to provide
+ * more complete USB functionality at least for Linux,
+ * and equivalent functionality should be brought back
+ * in for Windows and MacOSX.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ******************************************************/
+
+#ifndef NATIVEUSB_H
+#define NATIVEUSB_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* cplusplus */
+
+#define OPEN_OK          		0
+#define NO_DEVICE_FOUND 		-1
+#define NO_DEVICE_MATCH 		-2
+#define CLAIM_INTERFACE_FAILED 	-3
+#define CLOSE_OK         		0
+#define CLOSE_ERROR     		-1
+#define WRITE_FAILED    		-1
+#define READ_FAILED     		-1
+#define ABORT_OK         		0
+#define ABORT_FAILED    		-1
+#define RESET_OK         		0
+#define RESET_FAILED    		-1
+
+struct USBConfigurationDescriptor {
+    unsigned char bLength;
+    unsigned char bDescriptorType;
+    unsigned short wTotalLength;
+    unsigned char bNumInterfaces;
+    unsigned char bConfigurationValue;
+    unsigned char iConfiguration;
+    unsigned char bmAttributes;
+    unsigned char MaxPower;
+};
+
+struct USBDeviceDescriptor {
+    unsigned char bLength;
+    unsigned char bDescriptorType;
+    unsigned short bcdUSB;
+    unsigned char bDeviceClass;
+    unsigned char bDeviceSubClass;
+    unsigned char bDeviceProtocol;
+    unsigned char bMaxPacketSize0;
+    unsigned short idVendor;
+    unsigned short idProduct;
+    unsigned short bcdDevice;
+    unsigned char iManufacturer;
+    unsigned char iProduct;
+    unsigned char iSerialNumber;
+    unsigned char bNumConfigurations;
+};
+
+struct USBInterfaceDescriptor {
+    unsigned char bLength;
+    unsigned char bDescriptorType;
+    unsigned char bInterfaceNumber;
+    unsigned char bAlternateSetting;
+    unsigned char bNumEndpoints;
+    unsigned char bInterfaceClass;
+    unsigned char bInterfaceSubClass;
+    unsigned char bInterfaceProtocol;
+    unsigned char iInterface;
+};
+
+struct USBEndpointDescriptor {
+    unsigned char bLength;
+    unsigned char bDescriptorType;
+    unsigned char bEndpointAddress;
+    unsigned char bmAttributes;
+    unsigned short wMaxPacketSize;
+    unsigned char bInterval;
+};
+
+//------------------------------------------------------------------------------
+// This function attempts to discover all devices with the given product
+// and vendor IDs.  Descriptors for each found device will be placed in the
+// provided long buffer.
+//
+// PARAMETERS:
+// vendorID:  The vendor ID to match with devices on the bus
+// productID: The product ID to match with devices on the bus
+// output:    A buffer of longs that will be populated with unique IDs for each
+//            device found that matches the VID and PID
+// max_devices: A limit on how many IDs can be put into the output buffer
+//
+// RETURN VALUE:
+// The number of devices successfully found, or -1 if there was an error.
+int
+USBProbeDevices(int vendorID, int productID, unsigned long *output,
+        int max_devices);
+
+//------------------------------------------------------------------------------
+// This function attempts to open a device with the given product and vendor
+// ID's at the specified index.
+//
+// PARAMETERS:
+// deviceID:    The ID of a device that has been provided by probeDevices().
+// errorCode: A pointer to an integer that will be set to an error code of
+//            either NO_DEVICE_FOUND or NO_DEVICE_MATCH if an error occured
+//            while trying to open the device or OPEN_OK if the device was
+//            found and opened.
+//
+// RETURN VALUE:
+// Returns a void pointer which equals a handle to the device if the device was
+// found and opened successfully, or NULL if the device was not opened
+// successfully.  The value of the 'errorCode' parameter should be checked
+// against the following before using the handle:
+//  - NO_DEVICE_FOUND signifying that no device was found with the specified ID
+//        or that the device with the specified ID could not be opened
+//------------------------------------------------------------------------------
+void *
+USBOpen(unsigned long deviceID, int *errorCode);
+
+//------------------------------------------------------------------------------
+// This function attempts to close the device attached to the given handle.
+//
+// PARAMETERS:
+// handle: The device handle obtained via the open() function.
+//
+// RETURN VALUE:
+// Returns an integer which will be equal to either:
+//  - CLOSE_OK if the device was closed successfully
+//  - CLOSE_ERROR if some error occured
+//------------------------------------------------------------------------------
+int
+USBClose(void *handle);
+
+//------------------------------------------------------------------------------
+// This function writes the given data to the device attached to the given
+// handle.
+//
+// PARAMETERS:
+// handle: The device handle obtained via the open() function.
+// endpoint: The endpoint on the device to write the data to.
+// data: A pointer to the dynamically allocated byte array of data to be written
+// size: The number of bytes to be written
+//
+// RETURN VALUE:
+// Returns an integer which will be equal to either:
+//  - The number of bytes written to the endpoint if the write was successful
+//  - WRITE_FAILED if the data was not written to the device
+//------------------------------------------------------------------------------
+int
+USBWrite(void *handle, unsigned char endpoint, char * data, int numberOfBytes);
+
+//------------------------------------------------------------------------------
+// This function reads data from the device attached to the given handle into
+// the specified byte array.
+//
+// PARAMETERS:
+// handle: The device handle obtained via the open() function.
+// endpoint: The endpoint on the device to read the data from.
+// data: A pointer to the dynamically allocated byte array to store the data.
+// size: The number of bytes to be read.
+//
+// RETURN VALUE:
+// Returns an integer which will be equal to either:
+//  - The number of bytes read from the endpoint if the read was successful
+//  - READ_FAILED if the data was not successfully read from the device
+//------------------------------------------------------------------------------
+int
+USBRead(void *handle, unsigned char endpoint, char * data, int numberOfBytes);
+
+//------------------------------------------------------------------------------
+// This function attempts to clear any stall on the given endpoint.
+//
+// PARAMETERS:
+// handle: The device handle obtained via the open() function.
+// endpoint: The endpoint on the device to clear a stall condition on.
+//
+// RETURN VALUE:
+// No value is returned (void).
+//------------------------------------------------------------------------------
+void
+USBClearStall(void *handle, unsigned char endpoint);
+
+int
+USBGetDeviceDescriptor(void *handle, struct USBDeviceDescriptor *desc);
+
+int
+USBGetInterfaceDescriptor(void *handle, struct USBInterfaceDescriptor *desc);
+
+int
+USBGetEndpointDescriptor(void *handle, int endpoint_index, struct USBEndpointDescriptor *desc);
+
+int
+USBGetStringDescriptor(void *handle, unsigned int string_index, char *buffer, int maxLength);
+
+
+#ifdef __cplusplus
+}
+#endif /* _cplusplus */
+
+#endif /* NATIVEUSB_H */

source/OSIF/include/native/usb/USB.h

@@ -0,0 +1,84 @@
+/***************************************************//**
+ * @file    USB.h
+ * @date    February 2009
+ * @author  Ocean Optics, Inc.
+ *
+ * LICENSE:
+ *
+ * SeaBreeze Copyright (C) 2014, Ocean Optics Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *******************************************************/
+
+#ifndef SEABREEZE_USB_H
+#define SEABREEZE_USB_H
+
+#include "native/usb/USBDiscovery.h"
+#include "native/usb/NativeUSB.h"
+#include <string>
+
+namespace seabreeze {
+
+    /* Empty declaration of USBDiscovery to deal with cross-includes */
+    class USBDiscovery;
+
+    class USB {
+    public:
+        virtual ~USB();
+
+        bool open();
+        bool close();
+        int write(int endpoint, void *data, unsigned int length_bytes);
+        int read(int endpoint, void *data, unsigned int length_bytes);
+        void clearStall(int endpoint);
+
+        static void setVerbose(bool v);
+
+        int getDeviceDescriptor(struct USBDeviceDescriptor *desc);
+        int getInterfaceDescriptor(struct USBInterfaceDescriptor *desc);
+        /* Get the endpoint descriptor where index is the endpoint index. */
+        int getEndpointDescriptor(int index, struct USBEndpointDescriptor *epDesc);
+        std::string *getStringDescriptor(int index);
+        int getMaxPacketSize();
+
+        bool isOpened();
+
+        /* This allows the USBDiscovery class to access the protected
+         * constructor and act as a factory for USB instances.
+         */
+        friend class USBDiscovery;
+
+    protected:
+
+        /* These methods are primarily for debugging. */
+        void usbHexDump(void *x, int length, int endpoint);
+        void hexDump(void *x, int length);
+        void describeTransfer(const char *label, int length, void* data, int endpoint, bool hexdump);
+        USB(unsigned long deviceID);
+
+        void *descriptor;
+        bool opened;
+        static bool verbose;
+        unsigned long deviceID;
+    };
+
+}
+
+#endif