sensor_factory.hpp

Go to the documentation of this file.

#ifndef SENSOR_FACTORY_HPP
#define SENSOR_FACTORY_HPP

#include <vector>
#include <map>
#include <memory>

#include "../../../util/log/easylogging++.h"

#include "../../../util/error/kallisto_error.hpp"
#include "../../../util/executor/executor.hpp"
#include "../../../bluetooth/device/bluetooth_dispatcher.hpp"
#include "../synchronization/time_synchronizer.hpp"
#include "sensor_provider.hpp"
#include "sensor.hpp"

namespace kallisto {
namespace hardware {

class SensorFactory {
private:
    std::vector<std::unique_ptr<SensorProvider>> m_providers; //Holds the providers

public:
    SensorFactory(){
        m_providers = std::vector<std::unique_ptr<SensorProvider>>();
    }

    ~SensorFactory(){
        m_providers.clear();
    }

    error::KallistoDetailedResult registerProvider(std::unique_ptr<SensorProvider> provider){
        for(auto it = m_providers.begin(); it != m_providers.end(); it++){
            if(*it == provider){
                return error::KallistoDetailedResult::build(error::ERROR_INVALID_PARAM, "Already registered");
            }
        }
        m_providers.push_back(std::move(provider));
        return error::KallistoDetailedResult::build(error::SUCCESS);
    }

    error::KallistoDetailedResult unregisterProvider(std::unique_ptr<SensorProvider> provider){
        for(auto it = m_providers.begin(); it != m_providers.end(); it++){
            if(*it == provider){
                m_providers.erase(it);
                return error::KallistoDetailedResult::build(error::SUCCESS);
            }
        }

        return error::KallistoDetailedResult::build(error::ERROR_INVALID_PARAM, "Not registered");
    }

    std::vector<std::unique_ptr<SensorImpl> > build(Kallisto& kallisto, const std::map<std::string, std::vector<uint8_t>>& service_data,
                                                const std::map<uint16_t, std::vector<uint8_t> >& manufacturer_data, util::Executor& event_dispatcher,
                                                bluetooth::BluetoothDispatcher& bluetooth_dispatcher, TimeSynchronizer& sensor_synchonizer){
        std::vector<std::unique_ptr<SensorImpl> >  sensor_list = std::vector<std::unique_ptr<SensorImpl> >();

        for(auto it1 = m_providers.begin(); it1 != m_providers.end(); it1++){
            std::vector<std::unique_ptr<SensorImpl> >  list = (*it1)->provide(kallisto, service_data, manufacturer_data, event_dispatcher, bluetooth_dispatcher, sensor_synchonizer);

            for(auto it2 = list.begin(); it2 != list.end(); it2++){
                sensor_list.push_back(std::move(*it2));
            }
        }

        return sensor_list;
    }
};

} /* namespace hardware */
} /* namespace kallisto */

#endif // SENSOR_FACTORY_HPP