GenericSAXHandler.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2002-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
/****************************************************************************/
// A handler which converts occurring elements and attributes into enums
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <map>
#include <stack>
#include <sstream>
#include <vector>
#include <xercesc/sax2/Attributes.hpp>
#include <xercesc/sax2/DefaultHandler.hpp>
#include <utils/common/UtilExceptions.h>
#include <utils/common/StringBijection.h>
#include "SUMOSAXAttributes.h"
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class GenericSAXHandler : public XERCES_CPP_NAMESPACE::DefaultHandler {
 
public:
    GenericSAXHandler(
        SequentialStringBijection::Entry* tags, int terminatorTag,
        SequentialStringBijection::Entry* attrs, int terminatorAttr,
        const std::string& file, const std::string& expectedRoot = "");
 
 
    virtual ~GenericSAXHandler();
 
 
    void startElement(const XMLCh* const uri, const XMLCh* const localname,
                      const XMLCh* const qname, const XERCES_CPP_NAMESPACE::Attributes& attrs);
 
 
    void characters(const XMLCh* const chars, const XERCES3_SIZE_t length);
 
 
    void endElement(const XMLCh* const uri, const XMLCh* const localname,
                    const XMLCh* const qname);
 
 
    void registerParent(const int tag, GenericSAXHandler* handler);
 
 
    void setFileName(const std::string& name);
 
 
    const std::string& getFileName() const;
 
 
 
 
    void warning(const XERCES_CPP_NAMESPACE::SAXParseException& exception);
 
 
    void error(const XERCES_CPP_NAMESPACE::SAXParseException& exception);
 
 
    void fatalError(const XERCES_CPP_NAMESPACE::SAXParseException& exception);
 
    void setSection(const int element, const bool seen) {
        mySection = element;
        mySectionSeen = seen;
        mySectionOpen = seen;
        mySectionEnded = false;
    }
 
    bool sectionFinished() const {
        return mySectionEnded;
    }
 
    std::pair<int, SUMOSAXAttributes*> retrieveNextSectionStart() {
        std::pair<int, SUMOSAXAttributes*> ret = myNextSectionStart;
        myNextSectionStart.first = -1;
        myNextSectionStart.second = nullptr;
        return ret;
    }
 
    void needsCharacterData(const bool value = true) {
        myCollectCharacterData = value;
    }
 
    // Reader needs access to myStartElement, myEndElement
    friend class SUMOSAXReader;
 
protected:
    std::string buildErrorMessage(const XERCES_CPP_NAMESPACE::SAXParseException& exception);
 
    virtual void myStartElement(int element,
                                const SUMOSAXAttributes& attrs);
 
    virtual void myCharacters(int element,
                              const std::string& chars);
 
    virtual void myEndElement(int element);
 
    void callParentEnd(int element);
 
private:
    XMLCh* convert(const std::string& name) const;
 
    int convertTag(const std::string& tag) const;
 
private:
 
 
    // the type of the map from ids to their unicode-string representation
    typedef std::vector<XMLCh*> AttrMap;
 
    // the map from ids to their unicode-string representation
    AttrMap myPredefinedTags;
 
    std::vector<std::string> myPredefinedTagsMML;
 
 
 
 
    // the type of the map that maps tag names to ints
    typedef std::map<std::string, int> TagMap;
 
    // the map of tag names to their internal numerical representation
    TagMap myTagMap;
 
    std::vector<std::string> myCharactersVector;
 
    GenericSAXHandler* myParentHandler;
 
    int myParentIndicator;
 
    std::string myFileName;
 
    std::string myExpectedRoot;
 
    bool myCollectCharacterData = false;
 
    bool myRootSeen = false;
 
    int mySection = -1;
 
    bool mySectionSeen = false;
 
    bool mySectionEnded = false;
 
    bool mySectionOpen = false;
 
    std::pair<int, SUMOSAXAttributes*> myNextSectionStart;
 
 
private:
    GenericSAXHandler(const GenericSAXHandler& s);
 
    const GenericSAXHandler& operator=(const GenericSAXHandler& s);
 
};