Device.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#include <duds/hardware/devices/Sensor.hpp>
#include <atomic>
#include <thread>

namespace duds { namespace hardware { namespace devices {

namespace clocks {
    template<class SVT, class SQT, class TVT, class TQT>
    class GenericClock;
}

template<class SVT, class SQT, class TVT, class TQT>
class GenericDevice : public Something {
    std::atomic<unsigned int> destructWait = 0;
    class DestructCounter {
        std::atomic<unsigned int> &count;
    public:
        DestructCounter(std::atomic<unsigned int> &c) : count(c) {
            ++count;
        }
        ~DestructCounter() {
            --count;
        }
    };
public:
    typedef GenericSensor<SVT, SQT, TVT, TQT>  Sensor;
    typedef std::shared_ptr<Sensor>  SensorSptr;
    typedef std::shared_ptr<const Sensor>  ConstSensorSptr;
    typedef std::weak_ptr<Sensor>  SensorWptr;
    typedef duds::data::GenericMeasurement<SVT, SQT, TVT, TQT>  Measurement;
    typedef std::shared_ptr<Measurement>  MeasurementSptr;
    typedef std::shared_ptr<const Measurement>  ConstMeasurementSptr;
    typedef clocks::GenericClock<SVT, SQT, TVT, TQT>  Clock;
    typedef std::shared_ptr<Clock>  ClockSptr;
protected:
    std::vector<SensorSptr> sens;
    void setMeasurement(const ConstMeasurementSptr &store, int sIdx = 0) const {
        sens[sIdx]->meas = store;
    }
    void setMeasurement(ConstMeasurementSptr &&store, int sIdx = 0) const {
        sens[sIdx]->meas = std::move(store);
    }
    GenericDevice() = default;
    GenericDevice(const boost::uuids::uuid &id) : Something(id) { }
public:
    ~GenericDevice() {
        // prevent sensors from getting their Device
        for (auto s : sens) {
            s->dev = nullptr;
        }
        // wait for any stragglers
        while (destructWait > 0) {
            std::this_thread::yield();
        }
    }
    std::shared_ptr< GenericDevice< SVT, SQT, TVT, TQT > > sharedPtr() {
        // use this counter object to ensure this function returns before
        // this object's destructor concludes
        DestructCounter(destructWait);
        // should be empty if the destructor is running on another thread
        return std::static_pointer_cast< GenericDevice< SVT, SQT, TVT, TQT > >(
            Something::weak_from_this().lock()
        );
    }
    virtual void sample() = 0;
    virtual void sample(const ClockSptr &clock) = 0;
    unsigned int numSensors() const {
        return sens.size();
    }
    const SensorSptr &sensor(unsigned int sIdx = 0) const {
        return sens.at(sIdx);
    }
    //Unit sensorUnits(int sIdx) const;
    ConstMeasurementSptr currentMeasurement(unsigned int sIdx = 0) const {
        return sens.at(sIdx)->measurement();
    }
};

typedef GenericDevice<
    duds::data::GenericValue,
    double,
    duds::time::interstellar::NanoTime,
    float
> Device;

typedef std::shared_ptr<Device>  DeviceSptr;
typedef std::weak_ptr<Device>  DeviceWptr;


} } }