common-types.h

Go to the documentation of this file.

/* This file is part of SOMHunter.
 *
 * Copyright (C) 2021 Frantisek Mejzlik <frankmejzlik@protonmail.com>
 *                    Mirek Kratochvil <exa.exa@gmail.com>
 *                    Patrik Vesely <prtrikvesely@gmail.com>
 *                    Vit Skrhak <v.skrhak@gmail.com>
 *
 * SOMHunter is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 2 of the License, or (at your option)
 * any later version.
 *
 * SOMHunter is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * SOMHunter. If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef COMMON_TYPES_H_
#define COMMON_TYPES_H_
 
#include <cstdint>
#include <limits>
#include <set>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace sh {
/* ***
 *  Custom exceptions
 */
class NotLoggedInEx : public std::runtime_error {
public:
    NotLoggedInEx(const std::string& msg) : std::runtime_error{ msg } {}
};
 
// ---
 
struct DebugLogStreamPtrs {
    DebugLogStreamPtrs() = delete;
    DebugLogStreamPtrs& operator=(DebugLogStreamPtrs&) = delete;
    DebugLogStreamPtrs& operator=(DebugLogStreamPtrs&&) = delete;
    // ---
    std::stringstream& _summary;
    std::stringstream& _actions;
    std::stringstream& _results;
};
 
using UnixTimestamp = std::int64_t;
 
enum class SubmitResult { CORRECT, INCORRECT, NOT_LOGGED_IN };
 
// some types
using LogHash = std::string;
using KeywordId = size_t;
using KeywordIds = std::vector<KeywordId>;
using KwSearchId = std::pair<KeywordId, size_t>;
using KwSearchIds = std::vector<KwSearchId>;
using KwDescription = std::string;
 
// wordnet IDs
using SynsetId = size_t;
using SynsetStrings = std::vector<std::string>;
using SynsetIds = std::vector<SynsetId>;
 
using VideoId = unsigned;
using FrameNum = unsigned;
using ShotId = unsigned;
 
using FrameId = unsigned long;
using ScreenImgsCont = std::vector<FrameId>;
using FeatureMatrix = std::vector<std::vector<float>>;
using FeatureVector = std::vector<float>;
 
template <typename T_ = float>
using StdMatrix = std::vector<std::vector<T_>>;
 
template <typename T_ = float>
using StdVector = std::vector<T_>;
 
using LikesCont = std::set<FrameId>;
using BookmarksCont = std::set<FrameId>;
using ShownFramesCont = std::set<FrameId>;
 
using ScreenVideosCont = std::set<VideoId>;
 
#define SIZE_T_ERR_VAL (std::numeric_limits<size_t>::max)()
#define IMAGE_ID_ERR_VAL (std::numeric_limits<FrameId>::max)()
#define VIDEO_ID_ERR_VAL (std::numeric_limits<VideoId>::max)()
 
template <typename T_>
constexpr T_ ERR_VAL() {
    return std::numeric_limits<T_>::max();
}
 
enum class DisplayType {
    DNull,
    DTopKNN,
    DLoading,
    DSom,
    DEmbed,
    DTopN,
    DTopNContext,
    DRand,
    DVideoDetail,
    DVideoReplay,
    DRelocation,
    NumItems
};
 
inline DisplayType str_to_disp_type(const std::string& type_str) {
    /* !!! THIS MUST MATCH WITH `config/config-core.json` FILE !!!
            strings->displayTypes
    */
    if (type_str == "topn_display") return DisplayType::DTopN;
    if (type_str == "topn_context_display") return DisplayType::DTopNContext;
    if (type_str == "SOM_display") return DisplayType::DSom;
    if (type_str == "topknn_display") return DisplayType::DTopKNN;
    if (type_str == "video_detail") return DisplayType::DVideoDetail;
    if (type_str == "video_replay") return DisplayType::DVideoReplay;
 
    return DisplayType::NumItems;
}
 
inline std::string disp_type_to_str(DisplayType type) {
    /* !!! THIS MUST MATCH WITH `config/config-core.json` FILE !!!
            strings->displayTypes
    */
    std::string disp_type;
    switch (type) {
        case DisplayType::DTopN:
            disp_type = "topn_display";
            break;
 
        case DisplayType::DTopNContext:
            disp_type = "topn_context_display";
            break;
 
        case DisplayType::DSom:
            disp_type = "SOM_display";
            break;
 
        case DisplayType::DTopKNN:
            disp_type = "topknn_display";
            break;
 
        case DisplayType::DVideoDetail:
            disp_type = "video_detail";
            break;
 
        case DisplayType::DVideoReplay:
            disp_type = "video_replay";
            break;
        default:
            throw std::runtime_error{ "Uknown dusplay!" };
            break;
    }
 
    return disp_type;
}
 
constexpr size_t operator""_z(unsigned long long int x) { return static_cast<size_t>(x); }
 
struct Filters;
 
struct UsedTools {
    bool operator==(const UsedTools& other) const {
        return (text_search_used == other.text_search_used && bayes_used == other.bayes_used &&
                topknn_used == other.topknn_used && canvas_bitmap_used == other.canvas_bitmap_used &&
                canvas_text_used == other.canvas_text_used && relocation_used == other.relocation_used &&
                temporal_query_used == other.temporal_query_used && filters == other.filters);
    }
    UsedTools()
        : text_search_used(false),
          bayes_used(false),
          topknn_used(false),
          canvas_bitmap_used{ false },
          canvas_text_used{ false },
          relocation_used{ false },
          temporal_query_used{ false },
          filters{ nullptr } {}
 
    void reset() {
        text_search_used = false;
        bayes_used = false;
        topknn_used = false;
        canvas_bitmap_used = false;
        canvas_text_used = false;
        relocation_used = false;
        temporal_query_used = false;
        filters = nullptr;
    }
 
    bool text_search_used;
    bool bayes_used;
    bool topknn_used;
    bool canvas_bitmap_used;
    bool canvas_text_used;
    bool relocation_used;
    bool temporal_query_used;
 
    const Filters* filters;
};
 
struct SubmitData {
    SubmitData() : want_submit(false), frame_ID(IMAGE_ID_ERR_VAL) {}
 
    bool push_submit(FrameId fr_ID) {
        // If we're busy, notify caller
        if (want_submit) return false;
 
        want_submit = true;
        frame_ID = fr_ID;
        return true;
    }
 
    FrameId get_and_pop_submit() {
        want_submit = false;
        return frame_ID;
    }
 
    bool submit_requested() const { return want_submit; }
 
    bool want_submit;
    FrameId frame_ID;
};
 
using PageId = unsigned;
 
using Weekday = uint8_t;
using Hour = uint8_t;
using Year = uint16_t;
using LscId = std::string;
 
struct FiltersData {
    Weekday weekday;
 
    Hour hour;
 
    Year year;
 
    LscId LSC_id;
};
 
};  // namespace sh
 
#endif  // COMMON_TYPES_H_