DataType.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_DATATYPE_H
#define EVIO_6_0_DATATYPE_H


#include <string>


namespace evio {


    class DataType {

    public:

        static const DataType UNKNOWN32;
        static const DataType UINT32;
        static const DataType FLOAT32;
        static const DataType CHARSTAR8;
        static const DataType SHORT16;
        static const DataType USHORT16;
        static const DataType CHAR8;
        static const DataType UCHAR8;
        static const DataType DOUBLE64;
        static const DataType LONG64;
        static const DataType ULONG64;
        static const DataType INT32;
        static const DataType TAGSEGMENT;
        static const DataType ALSOSEGMENT;
        static const DataType ALSOBANK;
        static const DataType COMPOSITE;
        static const DataType BANK;
        static const DataType SEGMENT;

        // These types are only used when dealing with COMPOSITE data.
        // They are never transported independently and are stored in integers.
        static const DataType HOLLERIT;
        static const DataType NVALUE;
        static const DataType nVALUE;
        static const DataType mVALUE;

        // In C++ this seems to be useful on occasion
        static const DataType NOT_A_VALID_TYPE;


    private:

        uint32_t value;

        std::string name;

        int bytes;

    private:

        static DataType intToType[37];  // min size -> 37 = 0x24 + 1

        static std::string names[37];

        DataType(uint32_t val, std::string name, int byteLen = -1) : value(val), name(std::move(name)), bytes(byteLen) {}

    public:

        static const DataType & getDataType(uint32_t val) {
            if (val > 0x24 || (val > 0x10 && val < 0x20)) return UNKNOWN32;
            return intToType[val];
        }

        static std::string getName(uint32_t val) {
            if (val > 0x24 || (val > 0x10 && val < 0x20)) return "UNKNOWN32";
            return getDataType(val).names[val];
        }

        static DataType valueOf(std::string const & typeName) {
            int index = 0;
            for (std::string const & name : names) {
                if (name == typeName) {
                    return intToType[index];
                }
                index++;
            }
            return DataType::UNKNOWN32;
        }

        static bool isStructure(uint32_t dataType) {
            return  dataType == BANK.value    || dataType == ALSOBANK.value    ||
                    dataType == SEGMENT.value || dataType == ALSOSEGMENT.value ||
                    dataType == TAGSEGMENT.value;
        }

        static bool isBank(uint32_t dataType) {
            return (BANK.value == dataType || ALSOBANK.value == dataType);
        }

        static bool isSegment(uint32_t dataType) {
            return (SEGMENT.value == dataType || ALSOSEGMENT.value == dataType);
        }

        static bool isTagSegment(uint32_t dataType) {
            return (TAGSEGMENT.value == dataType);
        }



        const std::string & getName() const {return name;}

        uint32_t getValue() const {return value;}

        std::string toString() const {
            if      (*this == ALSOBANK)    return "BANK";
            else if (*this == ALSOSEGMENT) return "SEGMENT";
            return name;
        }


        bool isStructure() const {
            return ((*this == BANK)       ||
                    (*this == SEGMENT)    ||
                    (*this == TAGSEGMENT) ||
                    (*this == ALSOBANK)   ||
                    (*this == ALSOSEGMENT));
        }

        bool isBank() const {return (*this == BANK || *this == ALSOBANK);}

        bool isSegment() const {return (*this == SEGMENT || *this == ALSOSEGMENT);}

        bool isTagSegment() const {return (*this == TAGSEGMENT);}

        bool isInteger() const {
            return ((*this == UCHAR8)   ||
                    (*this == CHAR8)    ||
                    (*this == USHORT16) ||
                    (*this == SHORT16)  ||
                    (*this == UINT32)   ||
                    (*this == INT32)    ||
                    (*this == ULONG64)  ||
                    (*this == LONG64));
        }

        int getBytes() const {return bytes;}

        bool operator==(const DataType &rhs) const;

        bool operator!=(const DataType &rhs) const;
    };

}


#endif //EVIO_6_0_DATATYPE_H