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>
#include <geogram/third_party/zlib/zlib.h>
 
#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::pointer base_addr, index_t nb_elements
    ) {
        T* attrib = reinterpret_cast<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::pointer base_addr, index_t nb_elements            
    ) {
        char* attrib = reinterpret_cast<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::pointer base_addr, index_t nb_elements            
    ) {
        char* attrib = reinterpret_cast<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 (*AsciiAttributeSerializer)(
            FILE* file, Memory::pointer base_address, index_t nb_elements
        );
 
        static void register_ascii_attribute_serializer(
            const std::string& type_name,
            AsciiAttributeSerializer read,
            AsciiAttributeSerializer write
        );
 
        GeoFile(const std::string& filename);
 
        ~GeoFile();
 
        bool is_ascii() const {
            return ascii_;
        }
 
        const std::string& current_chunk_class() const {
            return current_chunk_class_;
        }
 
        long 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_int();
 
        void write_int(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();
 
        void write_size(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(index_t) + 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_;
        long current_chunk_size_;
        long current_chunk_file_pos_;
        std::map<std::string, AttributeSetInfo> attribute_sets_;
 
        static std::map<std::string, AsciiAttributeSerializer>
            ascii_attribute_read_;
 
        static std::map<std::string, AsciiAttributeSerializer>
            ascii_attribute_write_;
    };
 
    /**************************************************************/
    
    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();
 
        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