API Reference

This document provides detailed API documentation for all public classes and their methods.

Core Classes
Data Structures
Utility Classes
Type Definitions

Core Classes

Controller

Manages program flow and coordinates between data processing and user interface.

Header: include/sensor_data_cli/Controller.h

class Controller {
public:
    Controller();
    Controller(const Menu& menu, const SensorData& data);
    Controller(const Controller& other);
    ~Controller();

    // Configuration
    void SetMenu(const Menu& menu);
    Menu GetMenu() const;
    void SetSensorData(const SensorData& data);
    SensorData GetSensorData() const;

    // Data Loading
    bool LoadProxyData(const std::string& filePath, bool clearData = false);
    bool LoadData(const std::string& filePath, bool clearData = false);

    // Main Loop
    bool Run();

    // Calculations
    void CalcWindSpeedAvgStd(const int month = -1, const int year = -1);
    void CalcAmbientAirTempAvgStd(const int year = -1);
    void CalcSolarRadiationTotal(const int year = -1);
    void CalcSPCC(const int month = -1);
    void CalcAllReadings(const int year = -1);

    // Assignment
    Controller& operator=(const Controller& other);
};

Methods

`LoadProxyData(filePath, clearData)`

Loads sensor data from a proxy file (list of CSV paths).

Parameters:

filePath - Path to the proxy text file
clearData - If true, clears existing data before loading

Returns: true if loading succeeds

Example:

Controller ctrl;
if (ctrl.LoadProxyData("data/sources.txt", true)) {
    ctrl.Run();
}

`CalcWindSpeedAvgStd(month, year)`

Calculates average wind speed and standard deviation for a month.

Parameters:

month - Month (1-12), or -1 to prompt user
year - Year, or -1 to prompt user

Output: Prints to console via Menu

SensorData

Core data storage and statistical computation engine.

Header: include/sensor_data_cli/SensorData.h

class SensorData {
public:
    SensorData();
    SensorData(const SensorData& cpy);
    ~SensorData();

    // Data Management
    void InsertData(const SingleSensorData& single);
    void ClearData();
    bool LoadProxyFile(const std::string& fileName, bool clearData);
    bool LoadFile(const std::string& fileName, bool clearData);
    void SetupBST();

    // Statistics
    template <class T>
    Optional<float> CalcAvg(const DateTime& dt,
                           const std::string& header,
                           const Filter<T>& filter = Filter<T>());

    template <class T>
    Optional<float> CalcSTD(const DateTime& dt,
                           const std::string& header,
                           const Filter<T>& filter = Filter<T>());

    template <class T>
    Optional<float> CalcTotal(const DateTime& dt,
                             const std::string& header,
                             const Filter<T>& filter = Filter<T>());

    template <class T, class U>
    Optional<float> CalcSPCC(const DateTime& dt,
                            const std::string& h1,
                            const std::string& h2,
                            const Filter<T>& filter1 = Filter<T>(),
                            const Filter<U>& filter2 = Filter<U>());

    // Assignment
    SensorData& operator=(const SensorData& cpy);
};

Template Methods

`CalcAvg<T>(dt, header, filter)`

Calculates the arithmetic mean of values matching the criteria.

Template Parameter: T - Data type (int or float)

Parameters:

dt - DateTime specifying month/year
header - Column header name (e.g., SDH_WIND_SPEED)
filter - Optional range filter

Returns: Optional<float> - Average value, or empty if no data

Example:

SensorData data;
data.LoadFile("data.csv", true);

DateTime dt(Date(-1, 6, 2023), Time());
Optional<float> avg = data.CalcAvg<int>(dt, SDH_WIND_SPEED);
if (avg.HasValue()) {
    std::cout << "Average: " << avg.GetValue() << "\n";
}

class Menu {
public:
    Menu();
    Menu(const std::string& outputFile, const bool outputToFile);
    Menu(const Menu& other);
    ~Menu();

    // Configuration
    void SetOutputFile(const std::string& path);
    void SetOutputToFile(bool outputToFile);
    bool GetOutputToFile() const;
    std::string GetOutputfile() const;

    // Input
    int GetSelection();
    int GetMonth();
    int GetYear();

    // Output
    void PrintWindSpeedAvgStd(const Date& dt,
                             const Optional<float>& avg,
                             const Optional<float>& stdev);
    void PrintAmbientAirTempAvgStd(const Date& dt,
                                  const Optional<float>& avg,
                                  const Optional<float>& stdev);
    void PrintSolarRadiationTotal(const Date& dt,
                                 const Optional<float>& total_kwh);
    void PrintSPCC(const Date& dt,
                   const Optional<float>& st,
                   const Optional<float>& sr,
                   const Optional<float>& tr);
    void PrintAllReadings(const Date& dt,
                         const Optional<float>& windAvg,
                         const Optional<float>& windStd,
                         const Optional<float>& tempAvg,
                         const Optional<float>& tempStd,
                         const Optional<float>& total_kwh);
    void PrintYear(const DateTime& dt);
    void PrintCustom(const std::string& custom);

    // Assignment
    Menu& operator=(const Menu& other);
};

Date, Time, DateTime

Temporal data types for timestamps.

Date

Header: include/sensor_data_cli/Date.h

class Date {
public:
    Date();
    Date(const int day, const int month, const int year);
    Date(const Date& other);
    ~Date();

    // Getters/Setters
    int GetDay() const;
    void SetDay(const int day);
    int GetMonth() const;
    void SetMonth(const int month);
    int GetYear() const;
    void SetYear(const int year);
    std::string GetFullMonth() const;

    // Operators
    Date& operator=(const Date& other);
};

// Comparison operators
bool operator==(const Date& cmp, const Date& cmp2);
bool operator!=(const Date& cmp, const Date& cmp2);
bool operator>(const Date& cmp, const Date& cmp2);
bool operator<(const Date& cmp, const Date& cmp2);

// Stream operators
std::ostream& operator<<(std::ostream& os, const Date& date);
std::istream& operator>>(std::istream& input, Date& date);

Time

Header: include/sensor_data_cli/Time.h

class Time {
public:
    Time();
    Time(const int hour, const int minute, const int second);
    Time(const Time& other);
    ~Time();

    int GetHour() const;
    void SetHour(const int hour);
    int GetMinute() const;
    void SetMinute(const int minute);
    int GetSecond() const;
    void SetSecond(const int second);

    Time& operator=(const Time& other);
};

// Comparison operators
bool operator==(const Time& cmp, const Time& cmp2);
bool operator!=(const Time& cmp, const Time& cmp2);
bool operator>(const Time& cmp, const Time& cmp2);
bool operator<(const Time& cmp, const Time& cmp2);

// Stream operators
std::ostream& operator<<(std::ostream& os, const Time& time);
std::istream& operator>>(std::istream& input, Time& time);

DateTime

Header: include/sensor_data_cli/DateTime.h

class DateTime {
public:
    DateTime();
    DateTime(const Date& date, const Time& time);
    DateTime(const DateTime& other);
    ~DateTime();

    void SetDate(const Date& date);
    Date GetDate() const;
    void GetDate(Date& date) const;
    void SetTime(const Time& time);
    Time GetTime() const;
    void GetTime(Time& time) const;

    DateTime& operator=(const DateTime& other);
};

// Comparison operators
bool operator==(const DateTime& cmp, const DateTime& cmp2);
bool operator!=(const DateTime& cmp, const DateTime& cmp2);
bool operator>(const DateTime& cmp, const DateTime& cmp2);
bool operator<(const DateTime& cmp, const DateTime& cmp2);

Data Structures

Vector

Dynamic array with automatic resizing.

Header: include/sensor_data_cli/Vector.h

template <class T>
class Vector {
public:
    Vector();
    Vector(const int n);  // Initial capacity
    Vector(const Vector<T>& cpy);
    ~Vector();

    // Modifiers
    bool Insert(const T& obj);
    bool Insert(const T& obj, const int index);
    bool Delete(const int index);
    bool Clear();
    void Randomize();

    // Access
    int GetSize() const;
    void SetSize(const int size);
    int GetCapacity() const;
    bool SetCapacity(const int capacity);

    T& operator[](int index);
    const T& operator[](int index) const;

    // Assignment
    Vector<T>& operator=(const Vector<T>& cpy);
};

Usage Example

Vector<int> numbers;
numbers.Insert(10);
numbers.Insert(20);
numbers.Insert(30);

std::cout << "Size: " << numbers.GetSize() << "\n";
std::cout << "First: " << numbers[0] << "\n";

BST

Binary Search Tree for indexed data storage.

Header: include/sensor_data_cli/BST.h

template <class T>
class BST {
public:
    BST();
    BST(const BST& cpy);
    ~BST();

    bool IsEmpty() const;

    // Search
    bool Search(const T& data, fnAction* callback = nullptr, void* context = nullptr);
    bool Search(const T& lowerBound, const T& upperBound,
               fnAction* callback = nullptr, void* context = nullptr);

    // Modification
    bool Insert(const T& data);
    void Delete();

    // Traversal
    void PreOrder(fnAction* callback = nullptr, void* context = nullptr);
    void InOrder(fnAction* callback = nullptr, void* context = nullptr);
    void PostOrder(fnAction* callback = nullptr, void* context = nullptr);

    // Properties
    int Height() const;
    T GetLowerBound() const;
    T GetHigherBound() const;

    // Assignment
    BST& operator=(const BST& cpy);
};

Callback Function Signature

typedef void (*fnAction)(T &data, void* context);

Optional

Type-safe nullable value wrapper.

Header: include/sensor_data_cli/Optional.h

template<typename T>
class Optional {
public:
    Optional();                    // Empty optional
    Optional(const T& val);         // Optional with value

    bool HasValue() const;
    void SetValue(const T& val);
    T GetValue() const;
    operator T() const;  // Implicit conversion
};

Usage Example

Optional<float> result = CalculateAverage();

if (result.HasValue()) {
    float value = result.GetValue();
    std::cout << "Average: " << value << "\n";
} else {
    std::cout << "No data available\n";
}

Filter

Range-based filtering for data validation.

Header: include/sensor_data_cli/Filter.h

template <class T>
class Filter {
public:
    Filter();
    Filter(T lowerRange, T upperRange);

    // Lower bound
    void SetLowerRange(T lowerRange);
    T GetLowerRange() const;
    void RemoveLowerRange();
    bool HasLowerRangeSet() const;

    // Upper bound
    void SetUpperRange(T upperRange);
    T GetUpperRange() const;
    void RemoveUpperRange();
    bool HasUpperRangeSet() const;

    // Validation
    bool MeetsRange(T value) const;
};

Usage Example

Filter<int> filter;
filter.SetLowerRange(0);    // Must be >= 0
filter.SetUpperRange(100);  // Must be <= 100

if (filter.MeetsRange(50)) {
    // Value is in range [0, 100]
}

Utility Classes

Helper

Static utility functions for numeric operations.

Header: include/sensor_data_cli/Helper.h

class Helper {
public:
    // Rounding
    static float OneDP(const float oneDP);   // 1 decimal place
    static float TwoDP(const float twoDP);   // 2 decimal places
    static int Round(const float ft);

    // Unit Conversion
    static float ConvertToKWhPerM2(float power_W_per_m2, float duration_minutes);
    static float ConvertMpsToKmph(float speedMps);
};

DynamicStream

Output stream that can write to console or file.

Header: include/sensor_data_cli/DynamicStream.h

class DynamicStream {
public:
    DynamicStream();
    DynamicStream(const std::string& filePath, const bool writeToFile);
    DynamicStream(const DynamicStream& other);
    ~DynamicStream();

    void SetFilePath(const std::string& filePath);
    std::string GetFilePath() const;
    bool SetWriteToFile(const bool writeToFile);
    bool GetWriteToFile() const;

    DynamicStream& operator=(const DynamicStream& other);
};

Type Definitions

Sensor Data Headers

Standard header names defined in SingleSensorData.h:

#define SDH_TIMESTAMP             "WAST"
#define SDH_BARO_PERSSURE         "QFE"
#define SDH_BARO_PERSSURE_QFE     "QFF"
#define SDH_BARO_PERSSURE_AS      "QNH"
#define SDH_DDEW_POINT_TEMP       "DP"
#define SDH_EVAPORATION           "EV"
#define SDH_RAINFAILL             "RF"
#define SDH_RELATIVE_HUMIDITY     "RH"
#define SDH_SOIL_TEMP_125         "ST1"
#define SDH_SOIL_TEMP_250         "ST2"
#define SDH_SOIL_TEMP_500         "ST3"
#define SDH_SOIL_TEMP_1000        "ST4"
#define SDH_SOLAR_RAD             "SR"
#define SDH_AIR_TEMP              "T"
#define SDH_WIND_SPEED            "S"
#define SDH_WIND_DIRECTION_10AVG  "Dta"
#define SDH_WIND_DIRECTION_10SD   "Dts"
#define SDH_WIND_SPEED_MAX_WGUST  "Sx"

Menu Options Enum

enum MENU_OPTIONS {
    START_OF_SECTION = 0,
    WINDSPEED_AVG_STD,    // Option 1
    AAT_AVG_STD,          // Option 2
    SPCC,                 // Option 3
    ALL,                  // Option 4
    QUIT,                 // Option 5
    OUT_OF_SECTION
};

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

API Reference

Table of Contents

Core Classes

Controller

Methods

`LoadProxyData(filePath, clearData)`

`CalcWindSpeedAvgStd(month, year)`

SensorData

Template Methods

`CalcAvg<T>(dt, header, filter)`

Menu

Date, Time, DateTime

Date

Time

DateTime

Data Structures

Vector

Usage Example

BST

Callback Function Signature

Optional

Usage Example

Filter

Usage Example

Utility Classes

Helper

DynamicStream

Type Definitions

Sensor Data Headers

Menu Options Enum

See Also

FilesExpand file tree

api.md

Latest commit

History

api.md

File metadata and controls

API Reference

Table of Contents

Core Classes

Controller

Methods

LoadProxyData(filePath, clearData)

CalcWindSpeedAvgStd(month, year)

SensorData

Template Methods

CalcAvg<T>(dt, header, filter)

Menu

Date, Time, DateTime

Date

Time

DateTime

Data Structures

Vector

Usage Example

BST

Callback Function Signature

Optional

Usage Example

Filter

Usage Example

Utility Classes

Helper

DynamicStream

Type Definitions

Sensor Data Headers

Menu Options Enum

See Also

`LoadProxyData(filePath, clearData)`

`CalcWindSpeedAvgStd(month, year)`

`CalcAvg<T>(dt, header, filter)`