EvioDictionaryEntry.h

Go to the documentation of this file.

//
// Copyright 2020, Jefferson Science Associates, LLC.
// Subject to the terms in the LICENSE file found in the top-level directory.
//
// EPSCI Group
// Thomas Jefferson National Accelerator Facility
// 12000, Jefferson Ave, Newport News, VA 23606
// (757)-269-7100


#ifndef EVIO_6_0_EVIODICTIONARYENTRY_H
#define EVIO_6_0_EVIODICTIONARYENTRY_H


#include <sstream>
#include <memory>


#include "DataType.h"


namespace evio {


    class EvioDictionaryEntry {

        friend class EvioXMLDictionary;
        
    public:

        enum EvioDictionaryEntryType {
            TAG_NUM = 0,
            TAG_ONLY = 1,
            TAG_RANGE = 2
        };

    private:
        
        uint16_t tag= 0;

        uint16_t tagEnd = 0;

        uint8_t num = 0;

        bool numValid = false;

        DataType type {DataType::UNKNOWN32};

        std::string format = "";

        std::string description = "";

        EvioDictionaryEntryType entryType = TAG_NUM;

        std::shared_ptr<EvioDictionaryEntry> parentEntry = nullptr;




        EvioDictionaryEntry() = default;


        EvioDictionaryEntry(uint16_t tag, uint8_t num, uint16_t tagEnd, bool numValid,
                            DataType const & type, std::string const & description, std::string const & format,
                            std::shared_ptr<EvioDictionaryEntry> parent) {

            bool isRange = true;

            if (tagEnd == tag || tagEnd == 0) {
                // If both values equal each other or tagEnd == 0, there is no range.
                this->tag    = tag;
                this->tagEnd = 0;
                isRange = false;
            }
            else if (tagEnd < tag) {
                // Switch things so tag < tagEnd for simplicity
                this->tag = tagEnd;
                this->tagEnd = tag;
            }
            else {
                this->tag    = tag;
                this->tagEnd = tagEnd;
            }

            this->num = num;
            this->numValid = numValid;
            this->format = format;
            this->description = description;
            this->type = type;

            if (!isRange) {
                if (numValid) {
                    entryType = EvioDictionaryEntryType::TAG_NUM;
                }
                else {
                    entryType = EvioDictionaryEntryType::TAG_ONLY;
                }
            }
            else {
                entryType = EvioDictionaryEntryType::TAG_RANGE;
            }

            parentEntry = parent;
        }


    public:


        EvioDictionaryEntry(uint16_t tag, uint8_t num, DataType const & type) :
            EvioDictionaryEntry(tag, num, 0, true, type,
                    "", "", nullptr) {
        }


        explicit EvioDictionaryEntry(uint16_t tag, uint16_t tagEnd = 0,
                DataType const & type = DataType::UNKNOWN32,
                std::string const & description = "", std::string const & format = "",
                std::shared_ptr<EvioDictionaryEntry> parent = nullptr) :

            EvioDictionaryEntry(tag, 0, tagEnd, false, type, description, format, parent) {
        }

        explicit EvioDictionaryEntry(uint16_t tag, uint8_t num, uint16_t tagEnd = 0,
                                     DataType const & type = DataType::UNKNOWN32,
                                     std::string const & description = "", std::string const & format = "",
                                     std::shared_ptr<EvioDictionaryEntry> parent = nullptr) :

                EvioDictionaryEntry(tag, num, tagEnd, true, type, description, format, parent) {
        }


        bool inRange(uint16_t tagArg) const {
            return tagEnd != 0 && tagArg >= tag && tagArg <= tagEnd;
        }


        bool inRange(EvioDictionaryEntry & entry) const {
            return  tagEnd != 0 && entry.tag >= tag && entry.tag <= tagEnd;
        }


        bool operator==(const EvioDictionaryEntry &other) const {

            if (&other == this) return true;

            // Objects equal each other if tag & num & tagEnd are the same
            auto otherParent = other.getParentEntry();

            bool match = (tag == other.tag);
            match = match && (numValid == other.numValid);

            if (numValid) {
                match = match && (num == other.num);
            }

            // Now check tag range if any
            match = match && (tagEnd == other.tagEnd);

            // Now check if same entry type
            match = match && (entryType == other.entryType);

            // If both parent containers are defined, use them as well
            if (parentEntry != nullptr && otherParent != nullptr) {
                match = match && (parentEntry->getTag() == otherParent->getTag());
                match = match && (parentEntry->numValid == otherParent->numValid);
                if (parentEntry->numValid) {
                     match = match && (parentEntry->getNum() == otherParent->getNum());
                }
                match = match && (parentEntry->getTagEnd() == otherParent->getTagEnd());
                if (!match) std::cout << "  parents don't match" << std::endl;
            }

            return match;
        }

        bool operator!=(const EvioDictionaryEntry &rhs) const {
            return !(rhs == *this);
        }


        std::string toString() const {
            std::stringstream ss;

            switch (entryType) {
                case TAG_NUM:
                    ss << "(tag=" << tag << ",num =" << +num << ")" ;
                    break;
                case TAG_ONLY:
                    ss << "(tag=" << tag << ")" ;
                    break;
                case TAG_RANGE:
                    ss << "(tag=" << tag << "-" << tagEnd << ")" ;
            }

            return ss.str();
        }


        uint16_t getTag() const {return tag;}

        uint16_t getTagEnd() const {return tagEnd;}

        uint8_t getNum() const {return num;}

         DataType getType() const {return type;}

        std::string getFormat() const {return format;}

         std::string getDescription() const {return description;}

        EvioDictionaryEntryType getEntryType() const {return entryType;}

        std::shared_ptr<EvioDictionaryEntry> getParentEntry() const {return parentEntry;}

        std::string toString() {

            std::stringstream ss;

            ss << std::boolalpha;

            ss << "tag = " << tag << ", tagEnd = " << tagEnd << ", num = " << +num << ", numValid = " << numValid <<
                  ", data type = " << type.toString();

            if (entryType == TAG_NUM)
                ss << ", entry type = TAG/NUM";
            else if (entryType == TAG_ONLY)
                ss << ", entry type = TAG_ONLY";
            else if (entryType == TAG_RANGE)
                ss << ", entry type = TAG_RANGE";

            ss << std::endl;

            if (!format.empty()) {
                ss << "    format = " << format << std::endl;
            }

            if (!description.empty()) {
                ss << "    description = " << description << std::endl;
            }

            if (parentEntry != nullptr) {
                ss << "    parent = " << parentEntry->toString() << std::endl;
            }

            return ss.str();
        }

    };


}

#endif //EVIO_6_0_EVIODICTIONARYENTRY_H