HypoList.h

Go to the documentation of this file.

/*****************************************
 * This file is documented for Doxygen.
 * If you modify this file please update
 * the comments so that Doxygen will still
 * be able to work.
 ****************************************/
#ifndef HYPOLIST_H
#define HYPOLIST_H

#include <json.h>
#include <threadbaseclass.h>
#include <vector>
#include <list>
#include <queue>
#include <map>
#include <set>
#include <memory>
#include <utility>
#include <string>
#include <mutex>
#include <thread>
#include <random>
#include "Glass.h"
#include "Hypo.h"

namespace glasscore {

// forward declarations
class CSite;
class CPick;
class CCorrelation;

struct HypoCompare {
    bool operator()(const std::shared_ptr<CHypo> &lhs,
                    const std::shared_ptr<CHypo> &rhs) const {
        // sort by tSort
        if (lhs->getTSort() < rhs->getTSort()) {
            return (true);
        }
        return (false);
    }
};

class CHypoList : public glass3::util::ThreadBaseClass {
 public:
    explicit CHypoList(int numThreads = 1, int sleepTime = 50,
                        int checkInterval = 300);

    ~CHypoList();

    bool addHypo(std::shared_ptr<CHypo> hypo, bool scheduleProcessing = true,
        CPickList* parentThread = NULL);

    bool associateData(std::shared_ptr<CPick> pk);

    bool fitData(std::shared_ptr<CPick> pk);

    bool associateData(std::shared_ptr<CCorrelation> corr);

    void clear() override;

    bool receiveExternalMessage(std::shared_ptr<json::Object> com);

    bool processHypo(std::shared_ptr<CHypo> hyp);

    int getHypoProcessingQueueLength();

    std::vector<std::weak_ptr<CHypo>> getHypos(double t1, double t2);

    int getMaxAllowableHypoCount() const;

    int getCountOfTotalHyposProcessed() const;

    int length() const;

    bool findAndMergeMatchingHypos(std::shared_ptr<CHypo> hyp);

    int appendToHypoProcessingQueue(std::shared_ptr<CHypo> hyp);

    std::shared_ptr<CHypo> getNextHypoFromProcessingQueue();

    void removeHypo(std::shared_ptr<CHypo> hypo, bool reportCancel = true);

    bool requestHypo(std::shared_ptr<json::Object> com);

    bool resolveData(std::shared_ptr<CHypo> hypo, bool allowStealing = true);

    void setMaxAllowableHypoCount(int hypoMax);

    glass3::util::WorkState work() override;

    // constants
    static constexpr double k_nHypoSearchPastDurationForPick = 3600;

 private:
    void updatePosition(std::shared_ptr<CHypo> hyp);

    void eraseFromMultiset(std::shared_ptr<CHypo> hyp);

    std::atomic<int> m_iMaxAllowableHypoCount;

    std::atomic<int> m_iCountOfTotalHyposProcessed;

    std::list<std::weak_ptr<CHypo>> m_lHypoProcessingQueue;

    std::mutex m_HypoProcessingQueueMutex;

    std::multiset<std::shared_ptr<CHypo>, HypoCompare> m_msHypoList;

    std::map<std::string, std::shared_ptr<CHypo>> m_mHypo;

    mutable std::recursive_mutex m_HypoListMutex;

    // constants
    static const int k_nMaxAllowableHypoCountDefault = 100;

    static const unsigned int k_nNumberOfMergeAnnealIterations = 2000;

    static constexpr double k_dFinalMergeAnnealTimeStepSize = 0.01;

    static constexpr double k_dMergeStackImprovementRatio = 0.1;

    static constexpr double k_dMinimumRoundingProtectionRatio = 0.99;

    static constexpr double k_dExistingTimeTolerance = 5.0;

    static constexpr double k_dExistingDistanceTolerance = 0.5;
};
}  // namespace glasscore
#endif  // HYPOLIST_H