reader.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__GEOMETRY_READER_H
#define PLASK__GEOMETRY_READER_H
 
#include <functional>
 
#include "../utils/xml/reader.hpp"
#include "../axes.hpp"
#include "../material/db.hpp"
#include "../mesh/boundary_conditions.hpp"
#include "../manager.hpp"
#include "space.hpp"
 
namespace plask {
 
class PLASK_API GeometryReader {
 
    std::map<std::string, shared_ptr<GeometryObject> > autoNamedObjects;
 
  public:
 
    static constexpr const char* const XML_NAME_ATTR = "name";                        
    static constexpr const char* const XML_MATERIAL_ATTR = "material";                
    static constexpr const char* const XML_MATERIAL_TOP_ATTR = "material-top";        
    static constexpr const char* const XML_MATERIAL_BOTTOM_ATTR = "material-bottom";  
    static constexpr const char* const XML_MATERIAL_GRADING_ATTR = "material-shape";
 
    bool materialsAreRequired;
 
    typedef shared_ptr<GeometryObject> object_read_f(GeometryReader& reader);
 
    static std::map<std::string, object_read_f*>& objectReaders();
 
    static void registerObjectReader(const std::string& tag_name, object_read_f* reader);
 
    struct PLASK_API RegisterObjectReader {
        RegisterObjectReader(const std::string& tag_name, object_read_f* reader) {
            GeometryReader::registerObjectReader(tag_name, reader);
        }
    };
 
    const char* expectedSuffix;
 
    typedef std::function<GeometryObject::Changer*(GeometryReader& reader)> changer_read_f;
 
    static std::map<std::string, changer_read_f>& changerReaders();
 
    static void registerChangerReader(const std::string& tag_name, changer_read_f reader);
 
    struct PLASK_API RegisterChangerReader {
        RegisterChangerReader(const std::string& tag_name, changer_read_f reader) {
            GeometryReader::registerChangerReader(tag_name, reader);
        }
    };
 
    const AxisNames& getAxisNames() const;
 
    std::string getAxisName(std::size_t axis_index);
 
    std::string getAxisLongName() { return getAxisName(axis::lon_index); }
 
    std::string getAxisTranName() { return getAxisName(axis::tran_index); }
 
    std::string getAxisVertName() { return getAxisName(axis::up_index); }
 
    struct PLASK_API SetExpectedSuffix {
        GeometryReader& reader;
        const char* old;
        SetExpectedSuffix(GeometryReader& reader, const char* new_expected_suffix);
        SetExpectedSuffix(GeometryReader& reader, int dim);
        ~SetExpectedSuffix() { reader.expectedSuffix = old; }
    };
 
    struct PLASK_API RevertMaterialsAreRequired {
        GeometryReader& reader;
        bool old;
        RevertMaterialsAreRequired(GeometryReader &reader): reader(reader), old(reader.materialsAreRequired) {}
        RevertMaterialsAreRequired(GeometryReader& reader, bool new_value): reader(reader), old(reader.materialsAreRequired) { reader.materialsAreRequired = new_value; }
        ~RevertMaterialsAreRequired() { reader.materialsAreRequired = old; }
    };
 
    Manager& manager;
 
    XMLReader& source;
 
    const MaterialsDB* materialsDB;
 
    shared_ptr<Material> getMaterial(const std::string& material_full_name) const;
 
    shared_ptr<MaterialsDB::MixedCompositionFactory> getMixedCompositionFactory(const std::string& material1_full_name,
                                                                                const std::string& material2_full_name,
                                                                                double shape=1.) const;
 
    shared_ptr<Material> requireMaterial() const {
        try {
            return getMaterial(source.requireAttribute(XML_MATERIAL_ATTR));
        } catch (const XMLNoAttrException& err) {
            manager.throwErrorIfNotDraft(err);
            return plask::make_shared<DummyMaterial>("");
        }
    }
 
    SolidOrGradientMaterial requireSolidOrGradientMaterial() const;
 
    GeometryReader(Manager& manager, XMLReader& source, const MaterialsDB& materialsDB = MaterialsDB::getDefault());
 
    shared_ptr<GeometryObject> readObject();
 
    shared_ptr<GeometryObject> readExactlyOneChild();
 
    template <typename RequiredObjectType>
    shared_ptr<RequiredObjectType> readObject();
 
    template <typename RequiredObjectType>
    shared_ptr<RequiredObjectType> readExactlyOneChild();
 
    shared_ptr<Geometry> readGeometry();
 
    shared_ptr<GeometryObject> requireObjectWithName(const std::string& name) const;
 
    shared_ptr<GeometryObject> requireObjectFromAttribute(const std::string& attr) const {
        try {
            return requireObjectWithName(source.requireAttribute(attr));
        } catch (const XMLNoAttrException& err) {
            manager.throwErrorIfNotDraft(err);
            return shared_ptr<GeometryObject>();
        }
    }
 
    void registerObjectName(const std::string& name, shared_ptr<GeometryObject> object);
 
    void registerObjectName(const plask::optional<std::string>& name, shared_ptr<GeometryObject> object) {
        if (name) registerObjectName(*name, object);
    }
 
    void registerObjectName(const plask::optional<const std::string>& name, shared_ptr<GeometryObject> object) {
        if (name) registerObjectName(*name, object);
    }
 
 
    void registerObjectNameFromCurrentNode(shared_ptr<GeometryObject> object) {
        auto name = source.getAttribute(XML_NAME_ATTR);
        if (name) {
            std::replace(name->begin(), name->end(), '-', '_');
            registerObjectName(*name, object);
        }
    }
 
};
 
// specialization for most types
template <typename RequiredObjectType>
inline shared_ptr<RequiredObjectType> GeometryReader::readObject() {
    shared_ptr<RequiredObjectType> result = dynamic_pointer_cast<RequiredObjectType>(readObject());
    if (!result) manager.throwErrorIfNotDraft(UnexpectedGeometryObjectTypeException());
    return result;
}
 
// specialization for GeometryObject which doesn't require dynamic_cast
template <>
inline shared_ptr<GeometryObject> GeometryReader::readObject<GeometryObject>() {
    return readObject();
}
 
// specialization for most types
template <typename RequiredObjectType>
inline shared_ptr<RequiredObjectType> GeometryReader::readExactlyOneChild() {
    shared_ptr<GeometryObject> before_cast;
    bool require_end = true;
    if (source.requireNext((!manager.draft)
                               ? XMLReader::NODE_ELEMENT
                               : (XMLReader::NODE_ELEMENT | XMLReader::NODE_ELEMENT_END)) == XMLReader::NODE_ELEMENT)
        before_cast = readObject();
    else
        require_end = false;
    if (!require_end && manager.draft) {
        manager.pushError(XMLUnexpectedElementException(source, "new tag"));
        return shared_ptr<RequiredObjectType>();
    }
    shared_ptr<RequiredObjectType> result = dynamic_pointer_cast<RequiredObjectType>(before_cast);
    if (!result) manager.throwErrorIfNotDraft(UnexpectedGeometryObjectTypeException());
    if (require_end) source.requireTagEnd();
    return result;
}
 
// specialization for GeometryObject which doesn't required dynamic_cast
template <>
inline shared_ptr<GeometryObject> GeometryReader::readExactlyOneChild<GeometryObject>() {
    return readExactlyOneChild();
}
 
/*template <typename FunctorType, typename RequiredObjectType>
inline void GeometryReader::readAllObjects(XMLReader& source, FunctorType functor) {
    while(source.read()) {
        switch (source.getNodeType()) {
            case irr::io::EXN_ELEMENT_END: return;
            case irr::io::EXN_ELEMENT: functor(readObject<RequiredObjectType>(source));
            //TODO what with all other XML types (which now are just ignored)?
        }
    }
}*/
 
}   // namespace plask
 
#endif // PLASK__GEOMETRY_READER_H