FileHelpers.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Functions for an easier usage of files
/****************************************************************************/
#pragma once
#include <config.h>
#include <cassert>
#include <fstream>
#include <string>
#include <vector>
#include "SUMOTime.h"
#include "Translation.h"
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class FileHelpers {
public:
 
    static bool isReadable(std::string path);
 
    static bool isDirectory(std::string path);
 
 
    static std::string getFilePath(const std::string& path);
 
    static std::string getFileFromPath(std::string path, const bool removeExtension);
 
    static std::string addExtension(const std::string& path, const std::string& extension);
 
    static std::string getConfigurationRelative(const std::string& configPath, const std::string& path);
 
    static bool isSocket(const std::string& name);
 
    static bool isAbsolute(const std::string& path);
 
    static std::string checkForRelativity(const std::string& filename, const std::string& basePath);
 
    static std::string getCurrentDir();
 
    static std::vector<std::string> splitDirs(const std::string& filename);
 
    static std::string fixRelative(const std::string& filename, const std::string& basePath, const bool force, std::string curDir = "");
 
    static std::string prependToLastPathComponent(const std::string& prefix, const std::string& path);
 
    static std::string appendBeforeExtension(const std::string& path, const std::string& suffix, bool checkSep = true);
 
 
    static std::ostream& writeInt(std::ostream& strm, int value);
 
    static std::ostream& writeFloat(std::ostream& strm, double value);
 
    static std::ostream& writeByte(std::ostream& strm, unsigned char value);
 
    static std::ostream& writeString(std::ostream& strm, const std::string& value);
 
    static std::ostream& writeTime(std::ostream& strm, SUMOTime value);
 
    template <typename E>
    static std::ostream& writeEdgeVector(std::ostream& os, const std::vector<E>& edges);
 
    template <typename E>
    static void readEdgeVector(std::istream& in, std::vector<const E*>& edges, const std::string& rid);
};
 
 
template <typename E>
std::ostream& FileHelpers::writeEdgeVector(std::ostream& os, const std::vector<E>& edges) {
    FileHelpers::writeInt(os, (int)edges.size());
    std::vector<int> follow;
    int maxFollow = 0;
    E prev = edges.front();
    for (typename std::vector<E>::const_iterator i = edges.begin() + 1; i != edges.end(); ++i) {
        int idx = 0;
        for (; idx < prev->getNumSuccessors(); ++idx) {
            if (idx > 15) {
                break;
            }
            if (prev->getSuccessors()[idx] == (*i)) {
                follow.push_back(idx);
                if (idx > maxFollow) {
                    maxFollow = idx;
                }
                break;
            }
        }
        if (idx > 15 || idx == prev->getNumSuccessors()) {
            follow.clear();
            break;
        }
        prev = *i;
    }
    if (follow.empty()) {
        for (typename std::vector<E>::const_iterator i = edges.begin(); i != edges.end(); ++i) {
            FileHelpers::writeInt(os, (*i)->getNumericalID());
        }
    } else {
        const int bits = maxFollow > 3 ? 4 : 2;
        const int numFields = 8 * sizeof(int) / bits;
        FileHelpers::writeInt(os, -bits);
        FileHelpers::writeInt(os, edges.front()->getNumericalID());
        int data = 0;
        int field = 0;
        for (std::vector<int>::const_iterator i = follow.begin(); i != follow.end(); ++i) {
            data |= *i;
            field++;
            if (field == numFields) {
                FileHelpers::writeInt(os, data);
                data = 0;
                field = 0;
            } else {
                data <<= bits;
            }
        }
        if (field > 0) {
            FileHelpers::writeInt(os, data << ((numFields - field - 1) * bits));
        }
    }
    return os;
}
 
 
template <typename E>
void FileHelpers::readEdgeVector(std::istream& in, std::vector<const E*>& edges, const std::string& rid) {
    int size;
    in.read((char*) &size, sizeof(int));
    edges.reserve(size);
    int bitsOrEntry;
    in.read((char*) &bitsOrEntry, sizeof(int));
    if (bitsOrEntry < 0) {
        const int bits = -bitsOrEntry;
        const int numFields = 8 * sizeof(int) / bits;
        const int mask = (1 << bits) - 1;
        int edgeID;
        in.read((char*) &edgeID, sizeof(int));
        const E* prev = E::getAllEdges()[edgeID];
        assert(prev != 0);
        edges.push_back(prev);
        size--;
        int data = 0;
        int field = numFields;
        for (; size > 0; size--) {
            if (field == numFields) {
                in.read((char*) &data, sizeof(int));
                field = 0;
            }
            int followIndex = (data >> ((numFields - field - 1) * bits)) & mask;
            if (followIndex >= prev->getNumSuccessors()) {
                throw ProcessError(TLF("Invalid follower index in route '%'!", rid));
            }
            prev = prev->getSuccessors()[followIndex];
            edges.push_back(prev);
            field++;
        }
    } else {
        while (size > 0) {
            const E* edge = E::getAllEdges()[bitsOrEntry];
            if (edge == 0) {
                throw ProcessError(TLF("An edge within the route '%' is not known!", rid));
            }
            edges.push_back(edge);
            size--;
            if (size > 0) {
                in.read((char*) &bitsOrEntry, sizeof(int));
            }
        }
    }
}