Util.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_UTIL_H
#define EVIO_6_0_UTIL_H

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <regex>
#include <vector>
#include <fstream>

#include "EvioException.h"
#include "ByteOrder.h"
#include "ByteBuffer.h"
#include "EvioNode.h"
#include "IBlockHeader.h"
#include "DataType.h"


namespace evio {


    class Util {

    public:

        // Some methods to help deal with padding data to 4-byte boundaries

        static uint32_t getWords(uint32_t length) {
            uint32_t words = length/4;
            if (getPadding(length) > 0) words++;
            return words;
        }


        static uint32_t getPadding(uint32_t length) {
            static uint32_t padValue[4] = {0,3,2,1};
            return padValue[length%4];
        }


        //-----------------------------------------------------------------------


        static bool iStrEquals(const std::string& a, const std::string& b) {
            unsigned int sz = a.size();
            if (b.size() != sz)
                return false;
            for (unsigned int i = 0; i < sz; ++i)
                if (tolower(a[i]) != tolower(b[i]))
                    return false;
            return true;
        }


        static const DataType & getDataType(const std::string & type) {

            if (iStrEquals(type,"int8"))       return DataType::CHAR8;
            else if (iStrEquals(type,"uint8"))      return DataType::UCHAR8;
            else if (iStrEquals(type,"int16"))      return DataType::SHORT16;
            else if (iStrEquals(type,"uint16"))     return DataType::USHORT16;
            else if (iStrEquals(type,"int32"))      return DataType::INT32;
            else if (iStrEquals(type,"uint32"))     return DataType::UINT32;
            else if (iStrEquals(type,"int64"))      return DataType::LONG64;
            else if (iStrEquals(type,"uint64"))     return DataType::ULONG64;
            else if (iStrEquals(type,"long64"))     return DataType::LONG64;
            else if (iStrEquals(type,"ulong64"))    return DataType::ULONG64;
            else if (iStrEquals(type,"float32"))    return DataType::FLOAT32;
            else if (iStrEquals(type,"float64"))    return DataType::DOUBLE64;
            else if (iStrEquals(type,"double64"))   return DataType::DOUBLE64;
            else if (iStrEquals(type,"string"))     return DataType::CHARSTAR8;
            else if (iStrEquals(type,"composite"))  return DataType::COMPOSITE;
            else if (iStrEquals(type,"unknown32"))  return DataType::UNKNOWN32;
            else if (iStrEquals(type,"tagsegment")) return DataType::TAGSEGMENT;
            else if (iStrEquals(type,"segment"))    return DataType::ALSOSEGMENT;
            else if (iStrEquals(type,"bank"))       return DataType::ALSOBANK;

            return DataType::NOT_A_VALID_TYPE;
        }


        static void toIntArray(char const *data,  uint32_t dataLen,
                               const ByteOrder & byteOrder, uint32_t *dest) {

            if (data == nullptr || dest == nullptr) {
                throw EvioException("bad arg");
            }

            for (int i = 0; i < dataLen-3; i+=4) {
                dest[i/4] = toInt(data[i ], data[i+1], data[i+2], data[i+3], byteOrder);
            }
        }


        static uint32_t toInt(char b1, char b2, char b3, char b4, const ByteOrder & byteOrder) {

            if (byteOrder == ByteOrder::ENDIAN_BIG) {
                return (
                        (0xff & b1) << 24 |
                        (0xff & b2) << 16 |
                        (0xff & b3) <<  8 |
                        (0xff & b4)
                );
            }
            else {
                return (
                        (0xff & b1)       |
                        (0xff & b2) <<  8 |
                        (0xff & b3) << 16 |
                        (0xff & b4) << 24
                );
            }
        }


        static uint32_t toInt(uint8_t const * data, ByteOrder const & byteOrder) {
            if (data == nullptr) {
                throw EvioException("null arg");
            }

            if (byteOrder == ByteOrder::ENDIAN_BIG) {
                return (
                        (0xff & data[0]) << 24 |
                        (0xff & data[1]) << 16 |
                        (0xff & data[2]) <<  8 |
                        (0xff & data[3])
                );
            }
            else {
                return (
                        (0xff & data[0])       |
                        (0xff & data[1]) <<  8 |
                        (0xff & data[2]) << 16 |
                        (0xff & data[3]) << 24
                );
            }
        }


        static uint64_t toLong(uint8_t const * data, ByteOrder const & byteOrder) {
            if (data == nullptr) {
                throw EvioException("null arg");
            }

            if (byteOrder == ByteOrder::ENDIAN_BIG) {
                return (
                        (uint64_t)(0xff & data[0]) << 56 |
                        (uint64_t)(0xff & data[1]) << 48 |
                        (uint64_t)(0xff & data[2]) << 40 |
                        (uint64_t)(0xff & data[3]) << 32 |
                        (uint64_t)(0xff & data[4]) << 24 |
                        (uint64_t)(0xff & data[5]) << 16 |
                        (uint64_t)(0xff & data[6]) <<  8 |
                        (uint64_t)(0xff & data[7])
                );
            }
            else {
                return (
                        (uint64_t)(0xff & data[0])       |
                        (uint64_t)(0xff & data[1]) <<  8 |
                        (uint64_t)(0xff & data[2]) << 16 |
                        (uint64_t)(0xff & data[3]) << 24 |
                        (uint64_t)(0xff & data[4]) << 32 |
                        (uint64_t)(0xff & data[5]) << 40 |
                        (uint64_t)(0xff & data[6]) << 48 |
                        (uint64_t)(0xff & data[7]) << 56
                );
            }
        }


        static void toBytes(uint32_t data, const ByteOrder & byteOrder, uint8_t* dest) {

            if (dest == nullptr) {
                throw EvioException("bad arg(s)");
            }

            if (byteOrder == ByteOrder::ENDIAN_BIG) {
                dest[0] = (uint8_t)(data >> 24);
                dest[1] = (uint8_t)(data >> 16);
                dest[2] = (uint8_t)(data >>  8);
                dest[3] = (uint8_t)(data      );
            }
            else {
                dest[0] = (uint8_t)(data      );
                dest[1] = (uint8_t)(data >>  8);
                dest[2] = (uint8_t)(data >> 16);
                dest[3] = (uint8_t)(data >> 24);
            }
        }


        static void toBytes(uint64_t data, const ByteOrder & byteOrder, uint8_t* dest) {

            if (dest == nullptr) {
                throw EvioException("bad arg(s)");
            }

            if (byteOrder == ByteOrder::ENDIAN_BIG) {
                dest[0] = (uint8_t)(data >> 56);
                dest[1] = (uint8_t)(data >> 48);
                dest[2] = (uint8_t)(data >> 40);
                dest[3] = (uint8_t)(data >> 32);
                dest[4] = (uint8_t)(data >> 24);
                dest[5] = (uint8_t)(data >> 16);
                dest[6] = (uint8_t)(data >>  8);
                dest[7] = (uint8_t)(data      );
            }
            else {
                dest[0] = (uint8_t)(data      );
                dest[1] = (uint8_t)(data >>  8);
                dest[2] = (uint8_t)(data >> 16);
                dest[3] = (uint8_t)(data >> 24);
                dest[4] = (uint8_t)(data >> 32);
                dest[5] = (uint8_t)(data >> 40);
                dest[6] = (uint8_t)(data >> 48);
                dest[7] = (uint8_t)(data >> 56);
            }
        }


        static void toBytes(uint32_t data, const ByteOrder & byteOrder,
                            std::vector<uint8_t> & dest, size_t off) {

            if (byteOrder == ByteOrder::ENDIAN_BIG) {
                dest[off  ] = (uint8_t)(data >> 24);
                dest[off+1] = (uint8_t)(data >> 16);
                dest[off+2] = (uint8_t)(data >>  8);
                dest[off+3] = (uint8_t)(data      );
            }
            else {
                dest[off  ] = (uint8_t)(data      );
                dest[off+1] = (uint8_t)(data >>  8);
                dest[off+2] = (uint8_t)(data >> 16);
                dest[off+3] = (uint8_t)(data >> 24);
            }
        }


        static void toBytes(uint16_t data, const ByteOrder & byteOrder, uint8_t* dest) {

            if (dest == nullptr) {
                throw EvioException("bad arg(s)");
            }

            if (byteOrder == ByteOrder::ENDIAN_BIG) {
                dest[0] = (uint8_t)(data >>  8);
                dest[1] = (uint8_t)(data      );
            }
            else {
                dest[0] = (uint8_t)(data      );
                dest[1] = (uint8_t)(data >>  8);
            }
        }


        static void toBytes(uint16_t data, const ByteOrder & byteOrder,
                            std::vector<uint8_t> & dest, size_t off) {

            if (byteOrder == ByteOrder::ENDIAN_BIG) {
                dest[off  ] = (uint8_t)(data >>  8);
                dest[off+1] = (uint8_t)(data      );
            }
            else {
                dest[off  ] = (uint8_t)(data      );
                dest[off+1] = (uint8_t)(data >>  8);
            }
        }


        static const std::string& NO_NAME_STRING() {
            // Initialize the static variable
            static std::string s("???");
            return s;
        }


        static uint32_t findEvioVersion(ByteBuffer & bb, size_t initialPos) {
            // Look at first record header

            // Have enough remaining bytes to read 8 words of header?
            if (bb.limit() - initialPos < 32) {
                throw std::underflow_error("not enough data to read in header");
            }

            // Set the byte order to match the file's ordering.

            // Check the magic number for endianness (buffer defaults to big endian)
            ByteOrder byteOrder = bb.order();

            // Offset to magic # is in the SAME LOCATION FOR ALL EVIO VERSIONS
            uint32_t magicNumber = bb.getUInt(initialPos + IBlockHeader::MAGIC_OFFSET);
            if (magicNumber != IBlockHeader::MAGIC_NUMBER) {
                if (byteOrder == ByteOrder::ENDIAN_BIG) {
                    byteOrder = ByteOrder::ENDIAN_LITTLE;
                }
                else {
                    byteOrder = ByteOrder::ENDIAN_BIG;
                }
                bb.order(byteOrder);

                // Reread magic number to make sure things are OK
                magicNumber = bb.getInt(initialPos + IBlockHeader::MAGIC_OFFSET);
                if (magicNumber != IBlockHeader::MAGIC_NUMBER) {
                    throw EvioException("magic number is bad, " + std::to_string(magicNumber));
                }
            }

            // Find the version number, again, SAME LOCATION FOR ALL EVIO VERSIONS
            uint32_t bitInfo = bb.getUInt(initialPos + IBlockHeader::BIT_INFO_OFFSET);
            return bitInfo & IBlockHeader::VERSION_MASK;
        }


        static void printBytes(const std::shared_ptr<ByteBuffer> buf, uint32_t position, uint32_t bytes,
                               const std::string & label) {
            printBytes(*(buf.get()), position, bytes, label);
        }

        static void printBytes(const ByteBuffer & buf, uint32_t position, uint32_t bytes, const std::string & label) {

            // Make sure we stay in bounds
            bytes = bytes + position > buf.capacity() ? (buf.capacity() - position) : bytes;

            if (!label.empty()) std::cout << label << ":" << std::endl;

            if (bytes < 1) {
                std::cout << "  no data in buf from position = " << position << std::endl;
                return;
            }

            for (int i=0; i < bytes; i++) {
                if (i%20 == 0) {
                    std::cout << std::endl << std::dec << std::right << std::setfill(' ') <<
                    "  Buf(" << std::setw(3) << (i + 1) <<
                    " - "<< std::setw(3) << (i + 20) << ") =  ";
                }
                else if (i%4 == 0) {
                    std::cout << "  ";
                }
                // Accessing buf in this way does not change position or limit of buffer
                std::cout << std::hex << std::noshowbase << std::internal << std::setfill('0') <<
                std::setw(2) << (int)(buf[i + position]) << " ";
            }

            std::cout << std::dec << std::endl << std::endl << std::setfill(' ');
        }


        static void printBytes(uint8_t const * data, uint32_t bytes, const std::string & label) {

            if (!label.empty()) std::cout << label << ":" << std::endl;

            if (bytes < 1) {
                return;
            }

            for (int i=0; i < bytes; i++) {
                if (i%20 == 0) {
                    std::cout << std::endl << std::dec << std::right << std::setfill(' ') <<
                              "  Buf(" << std::setw(3) << (i + 1) <<
                              " - "<< std::setw(3) << (i + 20) << ") =  ";
                }
                else if (i%4 == 0) {
                    std::cout << "  ";
                }
                // Accessing buf in this way does not change position or limit of buffer
                std::cout << std::hex << std::noshowbase << std::internal << std::setfill('0') <<
                          std::setw(2) << (int)(*((data + i))) << " ";
            }

            std::cout << std::dec << std::endl << std::endl << std::setfill(' ');
        }


        static void printBytes(const std::string & fileName, uint64_t offset,
                               uint32_t bytes, const std::string & label) {

            if (fileName.empty()) {
                std::cout << "Util::printBytes: fileName arg is invalid" << std::endl;
                return;
            }

            try {
                std::ifstream inStreamRandom;

                // "ate" mode flag will go immediately to file's end (do this to get its size)
                inStreamRandom.open(fileName, std::ios::in | std::ios::ate);
                size_t fileSize = inStreamRandom.tellg();
                // Go back to beginning of file
                inStreamRandom.seekg(0);

                // read data
                uint64_t limit = bytes + offset > fileSize ? fileSize : bytes + offset;
                auto dataLen = (uint32_t)(limit - offset);
                ByteBuffer buf(dataLen);
                uint8_t * array = buf.array();
                inStreamRandom.read(reinterpret_cast<char *>(array), dataLen);

                printBytes(buf, 0, dataLen, label);
            }
            catch (std::exception & e) {
                // e.what() does not give any useful information...
                std::cout << "Util::printBytes: " << strerror(errno) << std::endl;
            }
        }


        static void writeBytes(const std::string & fileName, ByteBuffer & buf) {

            if (fileName.empty()) {
                std::cout << "Util::writeBytes: fileName arg is invalid" << std::endl;
                throw EvioException("fileName arg is invalid");
            }

            std::fstream file;
            file.open(fileName, std::ios::binary | std::ios::out);
            if (file.fail()) {
                std::cout << "error opening file " << fileName << std::endl;
                throw EvioException("error opening file " + fileName);
            }

            // Write this into a file
            file.write(reinterpret_cast<char *>(buf.array() + buf.arrayOffset() + buf.position()),
                       buf.remaining());

            if (file.fail()) {
                std::cout << "error writing to file " << fileName << std::endl;
                throw EvioException("error writing to file " + fileName);
            }
            file.close();
        }


        static void readBytes(const std::string & fileName, ByteBuffer & buf) {

            if (fileName.empty()) {
                std::cout << "Util::writeBytes: fileName arg is invalid" << std::endl;
                throw EvioException("fileName arg is invalid");
            }

            std::fstream file;
            file.open(fileName, std::ios::binary | std::ios::in);
            if (file.fail()) {
                std::cout << "error opening file " << fileName << std::endl;
                throw EvioException("error opening file " + fileName);
            }

            // Write this into a file
            file.read(reinterpret_cast<char *>(buf.array() + buf.arrayOffset() + buf.position()),
                       buf.remaining());

            if (file.fail()) {
                std::cout << "error reading from file " << fileName << std::endl;
                throw EvioException("error reading from file " + fileName);
            }
            file.close();
            buf.position(buf.limit());
        }


        static int powerOfTwo(int x, bool roundUp) {
            if (x < 0) return -1;

            // The following algorithm is found in
            // "Hacker's Delight" by Henry Warren Jr.

            if (roundUp) {
                x = x - 1;
                x |= (x>>1);
                x |= (x>>2);
                x |= (x>>4);
                x |= (x>>8);
                x |= (x>>16);
                return x + 1;
            }

            int y;
            do {
                y = x;
                x &= (x - 1);
            } while (x != 0);
            return y;
        }


        static void stringToASCII(const std::string & input, std::vector<uint8_t> & array) {
            size_t inputSize = input.size();
            array.clear();
            array.reserve(inputSize);

            for (int i=0; i < inputSize; i++) {
                array.push_back((uint8_t) input[i]);
            }
        }


        static void stringToASCII(const std::string & input, ByteBuffer & buf) {
            size_t inputSize = input.size();
            buf.clear();
            buf.expand(inputSize);

            for (int i=0; i < inputSize; i++) {
                buf.put(i, input[i]);
            }
        }


        //
        //  Methods for parsing strings in evio format.
        //  These are placed here to break the circular dependency between
        //  BaseStructure and CompositeData.
        //


        static uint32_t stringsToRawSize(std::vector<std::string> const & strings) {

            if (strings.empty()) {
                return 0;
            }

            uint32_t dataLen = 0;
            for (std::string const & s : strings) {
                dataLen += s.length() + 1; // don't forget the null char after each string
            }

            // Add any necessary padding to 4 byte boundaries.
            // IMPORTANT: There must be at least one '\004'
            // character at the end. This distinguishes evio
            // string array version from earlier version.
            int pads[] = {4,3,2,1};
            dataLen += pads[dataLen%4];

            return dataLen;
        }


        static uint32_t stringToRawSize(const std::string & str) {

            if (str.empty()) {
                return 0;
            }

            uint32_t dataLen = str.length() + 1; // don't forget the null char after each string

            // Add any necessary padding to 4 byte boundaries.
            // IMPORTANT: There must be at least one '\004'
            // character at the end. This distinguishes evio
            // string array version from earlier version.
            int pads[] = {4,3,2,1};
            dataLen += pads[dataLen%4];

            return dataLen;
        }


        static void stringsToRawBytes(std::vector<std::string> & strings,
                                      std::vector<uint8_t> & bytes) {

            if (strings.empty()) {
                bytes.clear();
                return;
            }

            // create some storage
            int dataLen = stringsToRawSize(strings);
            std::string strData;
            strData.reserve(dataLen);

            for (std::string const & s : strings) {
                // add string
                strData.append(s);
                // add ending null
                strData.append(1, '\000');
            }

            // Add any necessary padding to 4 byte boundaries.
            // IMPORTANT: There must be at least one '\004'
            // character at the end. This distinguishes evio
            // string array version from earlier version.
            int pads[] = {4,3,2,1};
            switch (pads[strData.length()%4]) {
                case 4:
                    strData.append(4, '\004');
                    break;
                case 3:
                    strData.append(3, '\004');
                    break;
                case 2:
                    strData.append(2, '\004');
                    break;
                case 1:
                    strData.append(1, '\004');
            }

            // Transform to ASCII
            bytes.resize(dataLen);
            for (int i=0; i < strData.length(); i++) {
                bytes[i] = strData[i];
            }
        }


        static void unpackRawBytesToStrings(std::vector<uint8_t> & bytes, size_t offset,
                                            std::vector<std::string> & strData) {
            unpackRawBytesToStrings(bytes, offset, bytes.size(), strData);
        }


        static void unpackRawBytesToStrings(std::vector<uint8_t> & bytes,
                                            size_t offset, size_t maxLength,
                                            std::vector<std::string> & strData) {
            int length = bytes.size() - offset;
            if (bytes.empty() || (length < 4)) return;

            // Don't read read more than maxLength ASCII characters
            length = length > maxLength ? maxLength : length;

            std::string sData(reinterpret_cast<const char *>(bytes.data()) + offset, length);
            return stringBuilderToStrings(sData, true, strData);
        }


        static void unpackRawBytesToStrings(uint8_t *bytes, size_t length,
                                            std::vector<std::string> & strData) {
            if (bytes == nullptr) return;

            std::string sData(reinterpret_cast<const char *>(bytes), length);
           // std::cout << "unpackRawBytesToStrings: string = " << sData << std::endl;
            return stringBuilderToStrings(sData, true, strData);
        }


        static void unpackRawBytesToStrings(ByteBuffer & buffer,
                                            size_t pos, size_t length,
                                            std::vector<std::string> & strData) {

            if (length < 4) return;

            std::string sData(reinterpret_cast<const char *>(buffer.array() + buffer.arrayOffset()) + pos, length);
            return stringBuilderToStrings(sData, false, strData);
        }


        static void stringBuilderToStrings(std::string const & strData, bool onlyGoodChars,
                                           std::vector<std::string> & strings) {

            // Each string is terminated with a null (char val = 0)
            // and in addition, the end is padded by ASCII 4's (char val = 4).
            // However, in the legacy versions of evio, there is only one
            // null-terminated string and anything as padding. To accommodate legacy evio, if
            // there is not an ending ASCII value 4, anything past the first null is ignored.
            // After doing so, split at the nulls. Do not use the String
            // method "split" as any empty trailing strings are unfortunately discarded.

            char c;
            std::vector<int> nullIndexList;
            nullIndexList.reserve(10);
            uint32_t nullCount = 0, goodChars = 0;
            bool badFormat = true;

            size_t length = strData.length();
            bool noEnding4 = false;
            if (strData[length - 1] != '\004') {
                noEnding4 = true;
            }

            for (int i=0; i < length; i++) {
                c = strData[i];

                // If char is a null
                if (c == 0) {
                    nullCount++;
                    nullIndexList.push_back(i);
                    // If evio v2 or 3, only 1 null terminated string exists
                    // and padding is just junk or nonexistent.
                    if (noEnding4) {
                        badFormat = false;
                        break;
                    }
                }
                // Look for any non-printing/control characters (not including null)
                // and end the string there. Allow tab & newline.
                else if ((c < 32 || c > 126) && c != 9 && c != 10) {
                    if (nullCount < 1) {
                        badFormat = true;
                        // Getting garbage before first null.
                        break;
                    }

                    // Already have at least one null & therefore a String.
                    // Now we have junk or non-printing ascii which is
                    // possibly the ending 4.

                    // If we have a 4, investigate further to see if format
                    // is entirely valid.
                    if (c == '\004') {
                        // How many more chars are there?
                        int charsLeft = length - (i+1);

                        // Should be no more than 3 additional 4's before the end
                        if (charsLeft > 3) {
                            badFormat = true;
                            break;
                        }
                        else {
                            // Check to see if remaining chars are all 4's. If not, bad.
                            for (int j=1; j <= charsLeft; j++) {
                                c = strData[i+j];
                                if (c != '\004') {
                                    badFormat = true;
                                    goto pastOuterLoop;
                                }
                            }
                            badFormat = false;
                            break;
                        }
                    }
                    else {
                        badFormat = true;
                        break;
                    }
                }

                pastOuterLoop:

                // Number of good ASCII chars we have
                goodChars++;
            }

            strings.clear();

            if (badFormat) {
                if (onlyGoodChars) {
                    // Return everything in one String WITHOUT garbage
                    std::string goodStr(strData.data(), goodChars);
                    strings.push_back(goodStr);
                    return;
                }
                // Return everything in one String including possible garbage
                strings.push_back(strData);
                return;
            }

            // If here, raw bytes are in the proper format

            int firstIndex = 0;
            for (int nullIndex : nullIndexList) {
                std::string str(strData.data() + firstIndex, (nullIndex - firstIndex));
                strings.push_back(str);
                firstIndex = nullIndex + 1;
            }
        }




        static void expandEnvironmentalVariables(std::string & text) {
            static std::regex env("\\$\\(([^)]+)\\)");
            std::smatch match;
            while ( std::regex_search(text, match, env) ) {
                char * s = getenv(match[1].str().c_str());
                std::string var(s == nullptr ? "" : s);
                text.replace(match[0].first, match[0].second, var);
                //text.replace(match.prefix().length(), match[0].length(), var);
            }
        }


        static uint32_t countAndFixIntSpecifiers(std::string & text) {
            static std::regex specifier("%(\\d*)([xd])");

            auto begin = std::sregex_iterator(text.begin(), text.end(), specifier);
            auto end   = std::sregex_iterator();
            uint32_t specifierCount = std::distance(begin, end);

            std::sregex_iterator i = begin;

            // Go thru all specifiers in text, only once
            for (int j = 0; j < specifierCount; j++) {
                if (j > 0) {
                    // skip over specifiers previously dealt with (text can change each loop)
                    i = std::sregex_iterator(text.begin(), text.end(), specifier);
                    int k=j;
                    while (k-- > 0) i++;
                }

                std::smatch match = *i;
                std::string specWidth = match[1].str();
                // Make sure any number preceding "x" or "d" starts with a 0 or else
                // there will be empty spaces in the resulting string (i.e. file name).
                if (specWidth.length() > 0 && specWidth[0] != '0') {
                    text.replace(match[1].first, match[1].second, "0" + specWidth);
                }
            }

            return specifierCount;
        }


        static int generateBaseFileName(const std::string & baseName, const std::string & runType,
                                        std::string & modifiedBaseName) {

            int* returnInts = new int[1];

            // Return the modified base file name
            modifiedBaseName = baseName;

            if (modifiedBaseName.length() < 1) {
                throw EvioException("empty string arg");
            }

            // Replace all %s occurrences with runType
            std::string::size_type pos;
            while ((pos = modifiedBaseName.find("%s")) != std::string::npos) {
                modifiedBaseName = (runType.length() < 1) ?  modifiedBaseName.replace(pos, 2, "") :
                                   modifiedBaseName.replace(pos, 2, runType);
            }

            // Scan for environmental variables of the form $(xxx)
            // and substitute the values for them (blank string if not found)
            expandEnvironmentalVariables(modifiedBaseName);

            // Count # of int specifiers, making sure any number preceding
            // "x" or "d" starts with a 0 or else there will be empty spaces
            // in the file name (%3x --> %03x).
            uint32_t specifierCount = countAndFixIntSpecifiers(modifiedBaseName);

            if (specifierCount > 3) {
                throw EvioException("baseName arg is improperly formatted");
            }

            // Return # of C-style int format specifiers
            return specifierCount;
        }


        static std::string generateFileName(std::string fileName, uint32_t specifierCount,
                                            uint32_t runNumber, uint64_t split, uint32_t splitNumber,
                                            uint32_t streamId, uint32_t streamCount) {

            if (streamCount < 1) streamCount = 1;
            if (splitNumber < 1) splitNumber = 0;
            if (runNumber < 0)   runNumber = 0;
            if (streamId < 0)    streamId = 0;
            bool oneStream = streamCount < 2;

            if (fileName.length() < 1) {
                fileName = "file";
            }

            //cout << "generateFileName: split# = " << splitNumber << ", start with    " << fileName <<
            //",    streamId = " << streamId << ", stream count = " << streamCount << ", one stream = " <<
            //oneStream << endl;
            // NOTE: no run #s are tacked on the end!

            // If we're splitting files which is always the case of CODA users ...
            if (split > 0L) {
                // For no specifiers:  tack stream id and split # onto end of file name
                if (specifierCount < 1) {
                    if (oneStream) {
                        fileName += "." + std::to_string(splitNumber);
                    }
                    else {
                        fileName += "." + std::to_string(streamId) +
                                    "." + std::to_string(splitNumber);
                    }
                }
                    // For 1 specifier: insert run # at specified location,
                    // then tack stream id and split # onto end of file name
                else if (specifierCount == 1) {
                    char tempChar[fileName.length() + 1024];
                    int err = std::sprintf(tempChar, fileName.c_str(), runNumber);
                    if (err < 0) throw EvioException("badly formatted file name");
                    std::string temp(tempChar);
                    fileName = temp;

                    if (oneStream) {
                        fileName += "." + std::to_string(splitNumber);
                    }
                    else {
                        fileName += "." + std::to_string(streamId) +
                                    "." + std::to_string(splitNumber);
                    }
                }
                    // For 2 specifiers: insert run # and split # at specified locations
                    // and place stream id immediately before split #.
                else if (specifierCount == 2) {
                    if (!oneStream) {
                        // In order to place streamId before split#, place a %d in the filename
                        // immediately before 2nd specifier.
                        static std::regex specifier("(%\\d*[xd])");
                        auto it = std::sregex_iterator(fileName.begin(), fileName.end(), specifier);

                        // Go to 2nd match
                        it++;
                        std::smatch match = *it;
                        fileName.replace(match[0].first, match[0].second, "%d." + match.str());

                        char tempChar[fileName.length() + 1024];
                        int err = std::sprintf(tempChar, fileName.c_str(), runNumber, streamId, splitNumber);
                        if (err < 0) throw EvioException("badly formatted file name");
                        std::string temp(tempChar);
                        fileName = temp;
                    }
                    else {
                        char tempChar[fileName.length() + 1024];
                        int err = std::sprintf(tempChar, fileName.c_str(), runNumber, splitNumber);
                        if (err < 0) throw EvioException("badly formatted file name");
                        std::string temp(tempChar);
                        fileName = temp;
                    }
                }
                    // For 3 specifiers: insert run #, stream id, and split # at specified locations
                else if (specifierCount == 3) {
                    char tempChar[fileName.length() + 1024];
                    int err = std::sprintf(tempChar, fileName.c_str(), runNumber, streamId, splitNumber);
                    if (err < 0) throw EvioException("badly formatted file name");
                    std::string temp(tempChar);
                    fileName = temp;
                }

            }
                // If we're not splitting files, then CODA isn't being used and stream id is
                // probably meaningless.
            else {
                // For no specifiers:  tack stream id onto end of file name
                if (specifierCount < 1) {
                    if (!oneStream) {
                        fileName += "." + std::to_string(streamId);
                    }
                }
                else if (specifierCount == 1) {
                    // Insert runNumber
                    char tempChar[fileName.length() + 1024];
                    int err = std::sprintf(tempChar, fileName.c_str(), runNumber);
                    if (err < 0) throw EvioException("badly formatted file name");
                    std::string temp(tempChar);
                    fileName = temp;

                    if (!oneStream) {
                        fileName += "." + std::to_string(streamId);
                    }
                }
                else if (specifierCount == 2) {
                    // First get rid of the extra (2nd) int format specifier as no split # exists
                    static std::regex specifier("(%\\d*[xd])");
                    auto it = std::sregex_iterator(fileName.begin(), fileName.end(), specifier);
                    // Go to 2nd match
                    it++;
                    std::smatch match = *it;
                    fileName.replace(match[0].first, match[0].second, "");

                    // Insert runNumber into first specifier
                    char tempChar[fileName.length() + 1024];
                    int err = std::sprintf(tempChar, fileName.c_str(), runNumber);
                    if (err < 0) throw EvioException("badly formatted file name");
                    std::string temp(tempChar);
                    fileName = temp;

                    if (!oneStream) {
                        fileName += "." + std::to_string(streamId);
                    }
                }
                else if (specifierCount == 3) {
                    // Get rid of extra (3rd) int format specifier as no split # exists
                    static std::regex specifier("(%\\d*[xd])");
                    auto it = std::sregex_iterator(fileName.begin(), fileName.end(), specifier);
                    // Go to 3rd match
                    it++; it++;
                    std::smatch match = *it;
                    fileName.replace(match[0].first, match[0].second, "");

                    // Insert runNumber into first specifier, stream id into 2nd
                    char tempChar[fileName.length() + 1024];
                    int err = std::sprintf(tempChar, fileName.c_str(), runNumber, streamId);
                    if (err < 0) throw EvioException("badly formatted file name");
                    std::string temp(tempChar);
                    fileName = temp;
                }
            }
            //cout << "generateFileName: end with    " << fileName << endl;

            return fileName;
        }

    };

}


#endif //EVIO_6_0_UTIL_H