geofile.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_BASIC_GEOFILE
#define GEOGRAM_BASIC_GEOFILE
 
#include <geogram/basic/common.h>
#include <geogram/basic/numeric.h>
#include <geogram/basic/memory.h>
#include <geogram/basic/string.h>
#ifdef GEOGRAM_USE_BUILTIN_DEPS
#include <geogram/third_party/zlib/zlib.h>
#else
#include <zlib.h>
#endif
 
#include <stdexcept>
#include <fstream>
#include <map>
 
 
namespace GEO {
 
    class GEOGRAM_API GeoFileException : public std::logic_error {
    public:
        GeoFileException(const std::string& s) : logic_error(s) {
        }
 
        GeoFileException(const GeoFileException& rhs) : logic_error(rhs) {
        }
 
        ~GeoFileException() GEO_NOEXCEPT override;
    };
 
    /**************************************************************/
 
    template <class T> inline bool read_ascii_attribute(
        FILE* file, Memory::pointer base_addr, index_t nb_elements
    ) {
        T* attrib = reinterpret_cast<T*>(base_addr);
        for(index_t i=0; i<nb_elements; ++i) {
            std::string buff;
            int res;
            while(char(res = fgetc(file)) != '\n') {
                if(res == EOF) {
                    return false;
                }
                buff.push_back(char(res));
            }
            if(!String::from_string(buff.c_str(),attrib[i])) {
                return false;
            }
        }
        return true;
    }
 
    template <class T> inline bool write_ascii_attribute(
        FILE* file, Memory::const_pointer base_addr, index_t nb_elements
    ) {
        const T* attrib = reinterpret_cast<const T*>(base_addr);
        for(index_t i=0; i<nb_elements; ++i) {
            if(
                fprintf(
                    file, "%s\n", String::to_string(attrib[i]).c_str()
                ) == 0
            ) {
                return false;
            }
        }
        return true;
    }
 
    template <> inline bool read_ascii_attribute<char>(
        FILE* file, Memory::pointer base_addr, index_t nb_elements
    ) {
        char* attrib = reinterpret_cast<char*>(base_addr);
        for(index_t i=0; i<nb_elements; ++i) {
            int val;
            if(fscanf(file, "%d", &val) == 0) {
                return false;
            }
            attrib[i] = char(val);
        }
        return true;
    }
 
    template <> inline bool write_ascii_attribute<char>(
        FILE* file, Memory::const_pointer base_addr, index_t nb_elements
    ) {
        const char* attrib = reinterpret_cast<const char*>(base_addr);
        for(index_t i=0; i<nb_elements; ++i) {
            if(fprintf(file, "%d\n", int(attrib[i])) == 0) {
                return false;
            }
        }
        return true;
    }
 
    template <> inline bool read_ascii_attribute<bool>(
        FILE* file, Memory::pointer base_addr, index_t nb_elements
    ) {
        char* attrib = reinterpret_cast<char*>(base_addr);
        for(index_t i=0; i<nb_elements; ++i) {
            int val;
            if(fscanf(file, "%d", &val) == 0) {
                return false;
            }
            attrib[i] = char(val);
        }
        return true;
    }
 
    template <> inline bool write_ascii_attribute<bool>(
        FILE* file, Memory::const_pointer base_addr, index_t nb_elements
    ) {
        const char* attrib = reinterpret_cast<const char*>(base_addr);
        for(index_t i=0; i<nb_elements; ++i) {
            if(fprintf(file, "%d\n", int(attrib[i])) == 0) {
                return false;
            }
        }
        return true;
    }
 
    /**************************************************************/
 
    class GEOGRAM_API GeoFile {
    public:
 
    typedef bool (*AsciiAttributeReadSerializer)(
        FILE* file, Memory::pointer base_address, index_t nb_elements
    );
 
    typedef bool (*AsciiAttributeWriteSerializer)(
        FILE* file, Memory::const_pointer base_address, index_t nb_elements
    );
 
    static void register_ascii_attribute_serializer(
        const std::string& type_name,
        AsciiAttributeReadSerializer read,
        AsciiAttributeWriteSerializer write
    );
 
    GeoFile(const std::string& filename);
 
    ~GeoFile();
 
    bool is_ascii() const {
        return ascii_;
    }
 
    bool gargantua_mode() const {
        return gargantua_mode_;
    }
 
    const std::string& current_chunk_class() const {
        return current_chunk_class_;
    }
 
    size_t current_chunk_size() const {
        return current_chunk_size_;
    }
 
    struct AttributeInfo {
 
        AttributeInfo() : element_size(0), dimension(0) {
        }
 
        AttributeInfo(
            const std::string& name_in,
            const std::string& element_type_in,
            size_t element_size_in,
            index_t dimension_in
        ) :
            name(name_in),
            element_type(element_type_in),
            element_size(element_size_in),
            dimension(dimension_in) {
        }
 
 
        std::string name;
 
        std::string element_type;
 
        size_t element_size;
 
        index_t dimension;
    };
 
    struct AttributeSetInfo {
 
        AttributeSetInfo() : nb_items(0), skip(false) {
        }
 
        AttributeSetInfo(
            const std::string& name_in,
            index_t nb_items_in
        ) :
            name(name_in),
            nb_items(nb_items_in),
            skip(false) {
        }
 
        const AttributeInfo* find_attribute(
            const std::string& name_in
        ) const {
            for(index_t i=0; i<attributes.size(); ++i) {
                if(attributes[i].name == name_in) {
                    return &(attributes[i]);
                }
            }
            return nullptr;
        }
 
        AttributeInfo* find_attribute(const std::string& name_in) {
            for(index_t i=0; i<attributes.size(); ++i) {
                if(attributes[i].name == name_in) {
                    return &(attributes[i]);
                }
            }
            return nullptr;
        }
 
        std::string name;
 
        index_t nb_items;
 
        vector<AttributeInfo> attributes;
 
        bool skip;
    };
 
    AttributeSetInfo* find_attribute_set(const std::string& name) {
        auto it = attribute_sets_.find(name);
        if(it == attribute_sets_.end()) {
            return nullptr;
        }
        return &(it->second);
    }
 
    const AttributeSetInfo* find_attribute_set(
        const std::string& name
    ) const {
        auto it = attribute_sets_.find(name);
        if(it == attribute_sets_.end()) {
            return nullptr;
        }
        return &(it->second);
    }
 
    index_t read_index_t();
 
    void write_index_t(index_t x, const char* comment = nullptr);
 
    index_t read_index_t_32();
 
    void write_index_t_32(index_t x, const char* comment = nullptr);
 
    std::string read_string();
 
    void write_string(const std::string& s, const char* comment = nullptr);
 
    size_t read_size_t();
 
    void write_size_t(size_t x);
 
    std::string read_chunk_class();
 
    void write_chunk_class(const std::string& chunk_class);
 
    void write_string_array(const std::vector<std::string>& strings);
 
    void read_string_array(std::vector<std::string>& strings);
 
 
    size_t string_size(const std::string& s) const {
        return sizeof(Numeric::uint32) + s.length();
    }
 
    size_t string_array_size(
        const std::vector<std::string>& strings
    ) const ;
 
    void read_chunk_header();
 
    void write_chunk_header(
        const std::string& chunk_class, size_t size
    );
 
    void check_chunk_size();
 
    void check_zlib_version();
 
    void clear_attribute_maps();
 
    protected:
    std::string filename_;
    gzFile file_;
    bool ascii_;
    FILE* ascii_file_;
    std::string current_chunk_class_;
    size_t current_chunk_size_;
    size_t current_chunk_file_pos_;
    std::map<std::string, AttributeSetInfo> attribute_sets_;
 
    static std::map<std::string, AsciiAttributeReadSerializer>
    ascii_attribute_read_;
 
    static std::map<std::string, AsciiAttributeWriteSerializer>
    ascii_attribute_write_;
 
    bool gargantua_mode_;
 
    bool convert_32_to_64_;
 
    bool convert_64_to_32_;
    };
 
    /**************************************************************/
 
    class GEOGRAM_API InputGeoFile : public GeoFile {
    public:
        InputGeoFile(const std::string& filename);
 
        const std::string& next_chunk();
 
        void read_attribute(void* addr);
 
 
        void skip_attribute_set();
 
 
        const AttributeSetInfo& current_attribute_set() const {
            geo_assert(current_attribute_set_ != nullptr);
            return *current_attribute_set_;
        }
 
        const AttributeInfo& current_attribute() const {
            geo_assert(current_attribute_ != nullptr);
            return *current_attribute_;
        }
 
        /*
         * \brief Gets the current user comment.
         * \return a const reference to the current user comment
         * \pre current chunk class is "CMNT" (COMMENT)
         */
        const std::string& current_comment() const {
            geo_assert(current_chunk_class_ == "CMNT");
            return current_comment_;
        }
 
 
        void read_command_line(std::vector<std::string>& args);
 
    protected:
        void skip_chunk();
 
        void read_and_convert_index_t_array(
            index_t* addr, size_t nb_elements, size_t element_size
        );
 
        AttributeSetInfo* current_attribute_set_;
        AttributeInfo* current_attribute_;
        std::string current_comment_;
 
    private:
        InputGeoFile(const InputGeoFile& rhs);
 
        InputGeoFile& operator=(const InputGeoFile& rhs);
    };
 
    /**************************************************************/
 
    class GEOGRAM_API OutputGeoFile : public GeoFile {
    public:
        OutputGeoFile(const std::string& filename, index_t compression_level=3);
 
        void write_attribute_set(
            const std::string& name, index_t nb_items
        );
 
        void write_attribute(
            const std::string& attribute_set_name,
            const std::string& attribute_name,
            const std::string& element_type,
            size_t element_size,
            index_t dimension,
            const void* data
        );
 
 
        void write_comment(const std::string& comment);
 
        void write_command_line(const std::vector<std::string>& args);
 
 
        void write_separator();
 
    private:
        OutputGeoFile(const InputGeoFile& rhs);
 
        OutputGeoFile& operator=(const InputGeoFile& rhs);
    };
 
    /**************************************************************/
}
 
#endif