ExcelWriter

class pandas::ExcelWriter

pandas C++ class.

Example

#include <pandas/pandas.h>
using namespace pandas;

// Use ExcelWriter
ExcelWriter obj;
// ... operations ...

Constructors

Signature	Location	Example
ExcelWriter(const ExcelWriter&) = delete	pd_excel.h:86
ExcelWriter(ExcelWriter&& other) noexcept	pd_excel.h:90

Indexing / Selection

Signature	Return Type	Location	Example
SheetData& get_or_create_sheet(const std::string& sheet_name)	SheetData&	pd_excel.h:121

Type Checking

Signature	Return Type	Location	Example
bool is_open() const	bool	pd_excel.h:105	View

Other Methods

Signature	Return Type	Location	Example
static bool check_extension(const std::string& ext)	static bool	pd_excel.h:104	View
void close()	void	pd_excel.h:103	View
static std::string col_to_letter(size_t col)	static std::string	pd_excel.h:142
static uint32_t crc32(const std::vector<uint8_t>& data)	static uint32_t	pd_excel.h:143
std::string date_format() const	std::string	pd_excel.h:96	View
std::string datetime_format() const	std::string	pd_excel.h:97	View
std::string engine() const	std::string	pd_excel.h:95	View
static std::string escape_xml(const std::string& str)	static std::string	pd_excel.h:141
bool has_sheet(const std::string& sheet_name) const	bool	pd_excel.h:124
std::string if_sheet_exists() const	std::string	pd_excel.h:98	View
std::string path() const	std::string	pd_excel.h:94	View
std::vector<std::string> sheet_names() const	std::vector<std::string>	pd_excel.h:99	View
static std::vector<std::string> supported_extensions()	static std::vector<std::string>	pd_excel.h:100	View
void write_xlsx()	void	pd_excel.h:140	View

Code Examples

The following examples are extracted from the test suite.

is_open (pd_test_2_all.cpp:4092)

            }
            if (writer.datetime_format() != "YYYY-MM-DD HH:MM:SS.fff") {
                std::cout << "  [FAIL] : datetime_format property incorrect" << std::endl;
                throw std::runtime_error("datetime_format property incorrect");
            }
            if (writer.if_sheet_exists() != "replace") {
                std::cout << "  [FAIL] : if_sheet_exists property incorrect" << std::endl;
                throw std::runtime_error("if_sheet_exists property incorrect");
            }

            if (!writer.is_open()) {
                std::cout << "  [FAIL] : is_open should be true" << std::endl;
                throw std::runtime_error("is_open should be true");
            }

            writer.close();

            if (writer.is_open()) {
                std::cout << "  [FAIL] : is_open should be false after close" << std::endl;
                throw std::runtime_error("is_open should be false after close");
            }

check_extension (pd_test_2_all.cpp:4112)

            }

            std::remove("temp/test_writer_props.xlsx");

            std::cout << " -> tests passed" << std::endl;
        }

        void pd_test_excel_writer_check_extension() {
            std::cout << "========= ExcelWriter check_extension ==============";

            if (!pandas::ExcelWriter::check_extension(".xlsx")) {
                std::cout << "  [FAIL] : .xlsx should be supported" << std::endl;
                throw std::runtime_error(".xlsx should be supported");
            }
            if (!pandas::ExcelWriter::check_extension(".XLSX")) {
                std::cout << "  [FAIL] : .XLSX should be supported (case insensitive)" << std::endl;
                throw std::runtime_error(".XLSX should be supported");
            }
            if (!pandas::ExcelWriter::check_extension(".xlsm")) {
                std::cout << "  [FAIL] : .xlsm should be supported" << std::endl;
                throw std::runtime_error(".xlsm should be supported");

close (pd_test_2_all.cpp:3486)

            // Check ZIP signature (PK..)
            file.seekg(0, std::ios::beg);
            char sig[4];
            file.read(sig, 4);
            if (sig[0] != 'P' || sig[1] != 'K' || sig[2] != 0x03 || sig[3] != 0x04) {
                std::cout << "  [FAIL] : in pd_test_excel_basic() : Invalid ZIP signature" << std::endl;
                throw std::runtime_error("pd_test_excel_basic failed: invalid ZIP signature");
            }

            file.close();
            std::cout << " -> tests passed" << std::endl;
        }

        // Test Excel export with custom sheet name
        void pd_test_excel_sheet_name() {
            std::cout << "========= Excel export with sheet name =============";

            std::map<std::string, std::vector<double>> data = {
                {"X", {1.1, 2.2, 3.3}},
                {"Y", {4.4, 5.5, 6.6}}

date_format (pd_test_2_all.cpp:4079)

                "YYYY/MM/DD", "YYYY-MM-DD HH:MM:SS.fff", "w", std::nullopt, "replace");

            if (writer.path() != "temp/test_writer_props.xlsx") {
                std::cout << "  [FAIL] : path property incorrect" << std::endl;
                throw std::runtime_error("path property incorrect");
            }
            if (writer.engine() != "xlsxwriter") {
                std::cout << "  [FAIL] : engine property incorrect: " << writer.engine() << std::endl;
                throw std::runtime_error("engine property incorrect");
            }
            if (writer.date_format() != "YYYY/MM/DD") {
                std::cout << "  [FAIL] : date_format property incorrect" << std::endl;
                throw std::runtime_error("date_format property incorrect");
            }
            if (writer.datetime_format() != "YYYY-MM-DD HH:MM:SS.fff") {
                std::cout << "  [FAIL] : datetime_format property incorrect" << std::endl;
                throw std::runtime_error("datetime_format property incorrect");
            }
            if (writer.if_sheet_exists() != "replace") {
                std::cout << "  [FAIL] : if_sheet_exists property incorrect" << std::endl;
                throw std::runtime_error("if_sheet_exists property incorrect");

datetime_format (pd_test_2_all.cpp:4083)

                throw std::runtime_error("path property incorrect");
            }
            if (writer.engine() != "xlsxwriter") {
                std::cout << "  [FAIL] : engine property incorrect: " << writer.engine() << std::endl;
                throw std::runtime_error("engine property incorrect");
            }
            if (writer.date_format() != "YYYY/MM/DD") {
                std::cout << "  [FAIL] : date_format property incorrect" << std::endl;
                throw std::runtime_error("date_format property incorrect");
            }
            if (writer.datetime_format() != "YYYY-MM-DD HH:MM:SS.fff") {
                std::cout << "  [FAIL] : datetime_format property incorrect" << std::endl;
                throw std::runtime_error("datetime_format property incorrect");
            }
            if (writer.if_sheet_exists() != "replace") {
                std::cout << "  [FAIL] : if_sheet_exists property incorrect" << std::endl;
                throw std::runtime_error("if_sheet_exists property incorrect");
            }

            if (!writer.is_open()) {
                std::cout << "  [FAIL] : is_open should be true" << std::endl;

engine (pd_test_2_all.cpp:4075)

        void pd_test_excel_writer_properties() {
            std::cout << "========= ExcelWriter properties ===================";

            pandas::ExcelWriter writer("temp/test_writer_props.xlsx", "xlsxwriter",
                "YYYY/MM/DD", "YYYY-MM-DD HH:MM:SS.fff", "w", std::nullopt, "replace");

            if (writer.path() != "temp/test_writer_props.xlsx") {
                std::cout << "  [FAIL] : path property incorrect" << std::endl;
                throw std::runtime_error("path property incorrect");
            }
            if (writer.engine() != "xlsxwriter") {
                std::cout << "  [FAIL] : engine property incorrect: " << writer.engine() << std::endl;
                throw std::runtime_error("engine property incorrect");
            }
            if (writer.date_format() != "YYYY/MM/DD") {
                std::cout << "  [FAIL] : date_format property incorrect" << std::endl;
                throw std::runtime_error("date_format property incorrect");
            }
            if (writer.datetime_format() != "YYYY-MM-DD HH:MM:SS.fff") {
                std::cout << "  [FAIL] : datetime_format property incorrect" << std::endl;
                throw std::runtime_error("datetime_format property incorrect");

if_sheet_exists (pd_test_2_all.cpp:4087)

                throw std::runtime_error("engine property incorrect");
            }
            if (writer.date_format() != "YYYY/MM/DD") {
                std::cout << "  [FAIL] : date_format property incorrect" << std::endl;
                throw std::runtime_error("date_format property incorrect");
            }
            if (writer.datetime_format() != "YYYY-MM-DD HH:MM:SS.fff") {
                std::cout << "  [FAIL] : datetime_format property incorrect" << std::endl;
                throw std::runtime_error("datetime_format property incorrect");
            }
            if (writer.if_sheet_exists() != "replace") {
                std::cout << "  [FAIL] : if_sheet_exists property incorrect" << std::endl;
                throw std::runtime_error("if_sheet_exists property incorrect");
            }

            if (!writer.is_open()) {
                std::cout << "  [FAIL] : is_open should be true" << std::endl;
                throw std::runtime_error("is_open should be true");
            }

            writer.close();

path (pd_test_2_all.cpp:4071)

            std::cout << " -> tests passed" << std::endl;
        }

        void pd_test_excel_writer_properties() {
            std::cout << "========= ExcelWriter properties ===================";

            pandas::ExcelWriter writer("temp/test_writer_props.xlsx", "xlsxwriter",
                "YYYY/MM/DD", "YYYY-MM-DD HH:MM:SS.fff", "w", std::nullopt, "replace");

            if (writer.path() != "temp/test_writer_props.xlsx") {
                std::cout << "  [FAIL] : path property incorrect" << std::endl;
                throw std::runtime_error("path property incorrect");
            }
            if (writer.engine() != "xlsxwriter") {
                std::cout << "  [FAIL] : engine property incorrect: " << writer.engine() << std::endl;
                throw std::runtime_error("engine property incorrect");
            }
            if (writer.date_format() != "YYYY/MM/DD") {
                std::cout << "  [FAIL] : date_format property incorrect" << std::endl;
                throw std::runtime_error("date_format property incorrect");

sheet_names (pd_test_2_all.cpp:4049)

            pandas::ExcelWriter writer("temp/test_writer_names.xlsx");

            std::map<std::string, std::vector<int>> data = {{"A", {1}}};
            pandas::DataFrame df(data);

            df.to_excel(writer, "First");
            df.to_excel(writer, "Second");
            df.to_excel(writer, "Third");

            auto names = writer.sheet_names();
            if (names.size() != 3) {
                std::cout << "  [FAIL] : sheet_names: expected 3, got " << names.size() << std::endl;
                throw std::runtime_error("sheet_names: wrong count");
            }
            if (names[0] != "First" || names[1] != "Second" || names[2] != "Third") {
                std::cout << "  [FAIL] : sheet_names: wrong order or names" << std::endl;
                throw std::runtime_error("sheet_names: wrong order");
            }

            writer.close();

supported_extensions (pd_test_2_all.cpp:4139)

                std::cout << "  [FAIL] : .xls should not be supported" << std::endl;
                throw std::runtime_error(".xls should not be supported");
            }

            std::cout << " -> tests passed" << std::endl;
        }

        void pd_test_excel_writer_supported_extensions() {
            std::cout << "========= ExcelWriter supported_extensions =========";

            auto exts = pandas::ExcelWriter::supported_extensions();
            if (exts.size() < 2) {
                std::cout << "  [FAIL] : expected at least 2 extensions" << std::endl;
                throw std::runtime_error("expected at least 2 extensions");
            }

            bool found_xlsx = false;
            for (const auto& ext : exts) {
                if (ext == ".xlsx") {
                    found_xlsx = true;
                    break;

write_xlsx (pd_test_5_all.cpp:83986)

    put_u16(out, 0);                                         // start disk
    put_u16(out, static_cast<uint16_t>(entries.size()));     // disk entries
    put_u16(out, static_cast<uint16_t>(entries.size()));     // total entries
    put_u32(out, cd_size);
    put_u32(out, cd_start);
    put_u16(out, 0);                                         // comment len

    return out;
}

static std::string write_xlsx(const std::string& path,
                              const std::vector<Sheet>& sheets) {
    // Collect shared strings (dedup).
    std::vector<std::string> shared;
    auto sidx = [&](const std::string& s) -> size_t {
        for (size_t i = 0; i < shared.size(); ++i)
            if (shared[i] == s) return i;
        shared.push_back(s);
        return shared.size() - 1;
    };