From 85e1b4a333d143612cac697701e7c72241cbcdb5 Mon Sep 17 00:00:00 2001
From: Thomas Fussell <thomas.fussell@gmail.com>
Date: Fri, 10 Jun 2016 13:40:50 -0400
Subject: [PATCH] refactor styles... again

---
 include/xlnt/cell/cell.hpp                    |  22 +-
 .../xlnt/serialization/excel_serializer.hpp   |   3 +
 .../xlnt/serialization/style_serializer.hpp   | 211 +---
 .../serialization/worksheet_serializer.hpp    |   4 +-
 .../{formattable.hpp => base_format.hpp}      |   8 +-
 include/xlnt/styles/fill.hpp                  |  24 +-
 include/xlnt/styles/font.hpp                  |   2 +
 include/xlnt/styles/format.hpp                |  17 +-
 include/xlnt/styles/style.hpp                 |   4 +-
 include/xlnt/workbook/workbook.hpp            |  11 +-
 include/xlnt/worksheet/worksheet.hpp          |   2 +
 source/cell/cell.cpp                          |  61 +-
 source/detail/cell_impl.hpp                   |   3 +
 source/detail/stylesheet.hpp                  | 172 +++
 source/detail/workbook_impl.hpp               |   9 +-
 source/serialization/excel_serializer.cpp     |  20 +-
 source/serialization/style_serializer.cpp     | 988 ++++++++----------
 .../serialization/tests/test_style_writer.hpp |  12 +-
 source/serialization/worksheet_serializer.cpp |   5 +-
 source/styles/common_style.cpp                |  72 +-
 source/styles/fill.cpp                        |  12 +
 source/styles/font.cpp                        |  18 +
 source/styles/format.cpp                      |  41 +-
 source/styles/number_format.cpp               |   2 +-
 source/styles/style.cpp                       |   8 +-
 source/styles/tests/test_stylesheet.hpp       |  23 +-
 source/workbook/workbook.cpp                  | 106 +-
 source/worksheet/worksheet.cpp                |   6 +
 28 files changed, 912 insertions(+), 954 deletions(-)
 rename include/xlnt/styles/{formattable.hpp => base_format.hpp} (95%)
 create mode 100644 source/detail/stylesheet.hpp

diff --git a/include/xlnt/cell/cell.hpp b/include/xlnt/cell/cell.hpp
index 0fa9c9a3..e2d77254 100644
--- a/include/xlnt/cell/cell.hpp
+++ b/include/xlnt/cell/cell.hpp
@@ -38,7 +38,6 @@ enum class calendar;
 class alignment;
 class border;
 class cell_reference;
-class cell_style;
 class comment;
 class fill;
 class font;
@@ -46,6 +45,7 @@ class format;
 class number_format;
 class protection;
 class relationship;
+class style;
 class workbook;
 class worksheet;
 
@@ -205,6 +205,26 @@ public:
     const format &get_format() const;
     
     void set_format(const format &new_format);
+    
+    void clear_format();
+    
+    // style
+
+    /// <summary>
+    /// Return true if this cell has had a format applied to it.
+    /// </summary>
+    bool has_style() const;
+
+    /// <summary>
+    /// Return a reference to the format applied to this cell.
+    /// </summary>
+    const style &get_style() const;
+    
+    void set_style(const style &new_style);
+    
+    void set_style(const std::string &style_name);
+    
+    void clear_style();
 
     /// <summary>
     /// Return the number format of this cell.
diff --git a/include/xlnt/serialization/excel_serializer.hpp b/include/xlnt/serialization/excel_serializer.hpp
index 96ca27bf..0b13d3e0 100644
--- a/include/xlnt/serialization/excel_serializer.hpp
+++ b/include/xlnt/serialization/excel_serializer.hpp
@@ -30,6 +30,7 @@
 
 #include <xlnt/xlnt_config.hpp>
 #include <xlnt/packaging/zip_file.hpp>
+#include <detail/stylesheet.hpp>
 
 namespace xlnt {
 
@@ -93,6 +94,8 @@ public:
     /// binary data to stream.
     /// </summary>
     bool save_stream_workbook(std::ostream &stream, bool as_template = false);
+    
+    xlnt::detail::stylesheet &get_stylesheet();
 
 private:
     /// <summary>
diff --git a/include/xlnt/serialization/style_serializer.hpp b/include/xlnt/serialization/style_serializer.hpp
index d99c6353..580b77cf 100644
--- a/include/xlnt/serialization/style_serializer.hpp
+++ b/include/xlnt/serialization/style_serializer.hpp
@@ -28,8 +28,6 @@
 #include <vector>
 
 #include <xlnt/xlnt_config.hpp>
-#include <xlnt/styles/style.hpp>
-#include <xlnt/workbook/workbook.hpp>
 
 namespace xlnt {
 
@@ -40,7 +38,7 @@ class conditional_format;
 class fill;
 class font;
 class format;
-class formattable;
+class base_format;
 class style;
 class number_format;
 class protection;
@@ -49,8 +47,10 @@ class style;
 class xml_document;
 class xml_node;
 
+namespace detail { struct stylesheet; }
+
 /// <summary>
-/// Reads and writes xl/styles.xml from/to an associated workbook.
+/// Reads and writes xl/styles.xml from/to an associated stylesheet.
 /// </summary>
 class XLNT_CLASS style_serializer
 {
@@ -58,11 +58,7 @@ public:
     /// <summary>
     /// Construct a style_serializer which can write styles.xml based on wb or populate wb
     /// with styles from an existing styles.xml.
-    style_serializer(workbook &wb);
-
-    //
-    // Primary methods
-    //
+    style_serializer(detail::stylesheet &s);
 
     /// <summary>
     /// Load all styles from xml_document into workbook given in constructor.
@@ -73,204 +69,13 @@ public:
     /// Populate parameter xml with an XML tree representing the styles contained in the workbook
     /// given in the constructor.
     /// </summary>
-    xml_document write_stylesheet();
+    bool write_stylesheet(xml_document &xml);
 
-    // TODO: These need to be public for unit tests. Could also make test class a friend?
-    // private:
-
-    //
-    // Static element readers (i.e. readers that don't use internal state)
-    //
-
-    /// <summary>
-    /// Read and return an alignment from alignment_node.
-    /// </summary>
-    static alignment read_alignment(const xml_node &alignment_node);
-
-    /// <summary>
-    /// Read and return a border side from side_node.
-    /// </summary>
-    static side read_side(const xml_node &side_node);
-
-    /// <summary>
-    /// Read and return a border from border_node.
-    /// </summary>
-    static border read_border(const xml_node &border_node);
-
-    /// <summary>
-    /// Read and return a fill from fill_node.
-    /// </summary>
-    static fill read_fill(const xml_node &fill_node);
-
-    /// <summary>
-    /// Read and return a font from font_node.
-    /// </summary>
-    static font read_font(const xml_node &font_node);
-
-    /// <summary>
-    /// Read and return a number format from number_format_node.
-    /// </summary>
-    static number_format read_number_format(const xml_node &number_format_node);
-
-    /// <summary>
-    /// Read and return a protection from protection_node.
-    /// </summary>
-    static protection read_protection(const xml_node &protection_node);
-
-    /// <summary>
-    /// Read and return all indexed colors from indexed_colors_node.
-    /// </summary>
-    static std::vector<color> read_indexed_colors(const xml_node &indexed_colors_node);
-
-    /// <summary>
-    /// Read and return a color from color_node.
-    /// </summary>
-    static color read_color(const xml_node &color_node);
-
-    /// <summary>
-    /// Read and return a conditional format, dxf, from conditional_format_node.
-    /// </summary>
-    static conditional_format read_conditional_format(const xml_node &conditional_formats_node);
-
-    /// <summary>
-    /// Read a single format from the given node. In styles.xml, this is an "xf" element.
-    /// A format has an optional border id, fill id, font id, and number format id where
-    /// each id is an index in the corresponding list of borders, etc. A style also has
-    /// optional alignment and protection children. A style also defines whether each of
-    /// these is "applied". For example, a style with a defined font id, font=# but with
-    /// "applyFont=0" will not use the font in formatting.
-    /// </summary>
-    format read_format(const xml_node &format_node);
-    
-    /// <summary>
-    /// Read a single named style from the given named_style_node. In styles.xml, this is a
-    /// (confusingly named) "cellStyle" element. This node defines the name, whether it is
-    /// built-in and an xfId which is the index of an element in cellStyleXfs. style_format_node
-    /// should be the XML node of the element at the index of xfId.
-    /// </summary>
-    style read_style(const xml_node &style_node, const xml_node &style_format_node);
-    
-    //
-    // Non-static element readers (i.e. readers that modify internal state)
-    //
-    
-    bool read_number_formats(const xml_node &number_formats_node);
-
-    /// <summary>
-    /// Read all borders from borders_node and add them to workbook.
-    /// Return true on success.
-    /// </summary>
-    bool read_borders(const xml_node &borders_node);
-
-    /// <summary>
-    /// Read all fills from fills_node and add them to workbook.
-    /// Return true on success.
-    /// </summary>
-    bool read_fills(const xml_node &fills_node);
-
-    /// <summary>
-    /// Read all fonts from fonts_node and add them to workbook.
-    /// Return true on success.
-    /// </summary>
-    bool read_fonts(const xml_node &fonts_node);
-
-    /// <summary>
-    /// Read all colors from colors_node and add them to workbook.
-    /// Return true on success.
-    /// </summary>
-    bool read_colors(const xml_node &colors_node);
-    
-    /// <summary>
-    /// Read all cell styles from cell_styles_node and add them to workbook.
-    /// Return true on success.
-    /// </summary>
-    bool read_formats(const xml_node &formats_node);
-
-    /// <summary>
-    /// Read all named styles from named_style_node and cell_styles_node and add them to workbook.
-    /// Return true on success.
-    /// </summary>
-    bool read_styles(const xml_node &styles_node, const xml_node &style_formats_node);
-
-    /// <summary>
-    /// Read all borders from number_formats_node and add them to workbook.
-    /// Return true on success.
-    /// </summary>
-    bool read_stylesheet(const xml_node &number_formats_node);
-
-    //
-    // Non-static element writers (i.e. writers that modify internal workbook)
-    //
-
-    /// <summary>
-    /// Build an xml tree representing all borders in workbook into borders_node.
-    /// Returns true on success.
-    /// </summary>
-    bool write_borders(xml_node &borders_node) const;
-
-    /// <summary>
-    /// Build an xml tree representing all conditional formats in workbook into conditional_formats_node.
-    /// Returns true on success.
-    /// </summary>
-    bool write_conditional_formats(xml_node &conditional_formats_node) const;
-
-    /// <summary>
-    /// Build an xml tree representing all fills in workbook into fills_node.
-    /// Returns true on success.
-    /// </summary>
-    bool write_fills(xml_node &fills_node) const;
-
-    /// <summary>
-    /// Build an xml tree representing all fonts in workbook into fonts_node.
-    /// Returns true on success.
-    /// </summary>
-    bool write_fonts(xml_node &fonts_node) const;
-
-    /// <summary>
-    /// Build an xml tree representing all number formats in workbook into number_formats_node.
-    /// Returns true on success.
-    /// </summary>
-    bool write_number_formats(xml_node &number_formats_node) const;
-
-    bool write_formattable(const formattable &xf, xml_node xf_node) const;
-    
-    /// <summary>
-    /// Build an xml tree representing the given style into style_node.
-    /// Returns true on success.
-    /// </summary>
-    bool write_formats(xml_node &styles_node) const;
-    
-    bool write_styles(xml_node &cell_styles_node, xml_node &cell_style_formats_node) const;
-    
-    bool write_colors(xml_node &colors_node) const;
-    
-    bool write_ext_list(xml_node &ext_list_node) const;
-    
-    const std::vector<border> &get_borders() const;
-    
-    const std::vector<fill> &get_fills() const;
-    
-    const std::vector<font> &get_fonts() const;
-    
-    const std::vector<number_format> &get_number_formats() const;
-    
-    const std::vector<color> &get_colors() const;
-    
 private:
-    void initialize_vectors();
-    
     /// <summary>
-    /// Set in the constructor, this workbook is used as the source or target for all writing or reading, respectively.
+    /// Set in the constructor, this stylesheet is used as the source or target for all writing or reading, respectively.
     /// </summary>
-    workbook &workbook_;
-    
-    std::vector<color> colors_;
-    std::vector<border> borders_;
-    std::vector<fill> fills_;
-    std::vector<font> fonts_;
-    std::vector<number_format> number_formats_;
-    std::vector<format> formats_;
-    std::vector<style> styles_;
+    detail::stylesheet &stylesheet_;
 };
 
 } // namespace xlnt
diff --git a/include/xlnt/serialization/worksheet_serializer.hpp b/include/xlnt/serialization/worksheet_serializer.hpp
index 4f619d47..6ebb410d 100644
--- a/include/xlnt/serialization/worksheet_serializer.hpp
+++ b/include/xlnt/serialization/worksheet_serializer.hpp
@@ -36,6 +36,8 @@ class workbook;
 class worksheet;
 class xml_document;
 
+namespace detail { struct stylesheet; }
+
 /// <summary>
 /// Manages converting a worksheet to and from XML.
 /// </summary>
@@ -44,7 +46,7 @@ class XLNT_CLASS worksheet_serializer
 public:
     worksheet_serializer(worksheet sheet);
 
-    bool read_worksheet(const xml_document &xml);
+    bool read_worksheet(const xml_document &xml, detail::stylesheet &stylesheet);
     xml_document write_worksheet() const;
 
 private:
diff --git a/include/xlnt/styles/formattable.hpp b/include/xlnt/styles/base_format.hpp
similarity index 95%
rename from include/xlnt/styles/formattable.hpp
rename to include/xlnt/styles/base_format.hpp
index 30c59454..09f7cd9f 100644
--- a/include/xlnt/styles/formattable.hpp
+++ b/include/xlnt/styles/base_format.hpp
@@ -38,12 +38,12 @@ class cell;
 /// <summary>
 /// Describes the formatting of a particular cell.
 /// </summary>
-class XLNT_CLASS formattable : public hashable
+class XLNT_CLASS base_format : public hashable
 {
 public:
-    formattable();
-    formattable(const formattable &other);
-    formattable &operator=(const formattable &other);
+    base_format();
+    base_format(const base_format &other);
+    base_format &operator=(const base_format &other);
     
     void reset();
 
diff --git a/include/xlnt/styles/fill.hpp b/include/xlnt/styles/fill.hpp
index 9f071e2d..47034945 100644
--- a/include/xlnt/styles/fill.hpp
+++ b/include/xlnt/styles/fill.hpp
@@ -71,6 +71,8 @@ public:
         lightvertical,
         mediumgray,
     };
+    
+    fill();
 
     type get_type() const;
 
@@ -122,21 +124,21 @@ protected:
     std::string to_hash_string() const override;
 
 private:
-    type type_ = type::pattern;
-    pattern_type pattern_type_ = pattern_type::none;
+    type type_;
+    pattern_type pattern_type_;
     gradient_type gradient_type_;
     
-    double rotation_ = 0;
+    double rotation_;
     
-    std::experimental::optional<color> foreground_color_ = color::black();
-    std::experimental::optional<color> background_color_ = color::white();
-    std::experimental::optional<color> start_color_ = color::white();
-    std::experimental::optional<color> end_color_ = color::black();
+    std::experimental::optional<color> foreground_color_;
+    std::experimental::optional<color> background_color_;
+    std::experimental::optional<color> start_color_;
+    std::experimental::optional<color> end_color_;
     
-    double gradient_path_left_ = 0;
-    double gradient_path_right_ = 0;
-    double gradient_path_top_ = 0;
-    double gradient_path_bottom_ = 0;
+    double gradient_path_left_;
+    double gradient_path_right_;
+    double gradient_path_top_;
+    double gradient_path_bottom_;
 };
 
 } // namespace xlnt
diff --git a/include/xlnt/styles/font.hpp b/include/xlnt/styles/font.hpp
index 08f177ff..25ed6cb6 100644
--- a/include/xlnt/styles/font.hpp
+++ b/include/xlnt/styles/font.hpp
@@ -47,6 +47,8 @@ public:
         single,
         single_accounting
     };
+    
+    font();
 
     void set_bold(bool bold);
 
diff --git a/include/xlnt/styles/format.hpp b/include/xlnt/styles/format.hpp
index e03b031d..a8bb05f5 100644
--- a/include/xlnt/styles/format.hpp
+++ b/include/xlnt/styles/format.hpp
@@ -23,7 +23,7 @@
 // @author: see AUTHORS file
 #pragma once
 
-#include <xlnt/styles/formattable.hpp>
+#include <xlnt/styles/base_format.hpp>
 
 namespace xlnt {
 
@@ -33,28 +33,15 @@ namespace detail { struct workbook_impl; }
 /// <summary>
 /// Describes the formatting of a particular cell.
 /// </summary>
-class XLNT_CLASS format : public formattable
+class XLNT_CLASS format : public base_format
 {
 public:
     format();
     format(const format &other);
     format &operator=(const format &other);
     
-    // Named Style
-    bool has_style() const;
-    std::string get_style_name() const;
-    style &get_style();
-    const style &get_style() const;
-    void set_style(const std::string &name);
-    void set_style(const style &new_style);
-    void remove_style();
-    
 protected:
     std::string to_hash_string() const override;
-
-private:
-    detail::workbook_impl *parent_;
-    std::string named_style_name_;
 };
 
 } // namespace xlnt
diff --git a/include/xlnt/styles/style.hpp b/include/xlnt/styles/style.hpp
index c5968b29..9f219b0e 100644
--- a/include/xlnt/styles/style.hpp
+++ b/include/xlnt/styles/style.hpp
@@ -26,7 +26,7 @@
 #include <cstdint>
 #include <string>
 
-#include <xlnt/styles/formattable.hpp>
+#include <xlnt/styles/base_format.hpp>
 
 namespace xlnt {
 
@@ -36,7 +36,7 @@ class workbook;
 /// Describes a style which has a name and can be applied to multiple individual
 /// formats. In Excel this is a "Cell Style".
 /// </summary>
-class XLNT_CLASS style : public formattable
+class XLNT_CLASS style : public base_format
 {
 public:
     style();
diff --git a/include/xlnt/workbook/workbook.hpp b/include/xlnt/workbook/workbook.hpp
index 0c156437..2d968c8b 100644
--- a/include/xlnt/workbook/workbook.hpp
+++ b/include/xlnt/workbook/workbook.hpp
@@ -23,6 +23,7 @@
 // @author: see AUTHORS file
 #pragma once
 
+#include <functional>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -32,11 +33,14 @@
 #include <xlnt/xlnt_config.hpp>
 #include <xlnt/packaging/relationship.hpp>
 
+namespace CxxTest { class TestSuite; }
+
 namespace xlnt {
 
 class alignment;
 class app_properties;
 class border;
+class cell;
 class cell_style;
 class color;
 class const_worksheet_iterator;
@@ -193,10 +197,12 @@ public:
     const std::vector<format> &get_formats() const;
     
     // Named Styles
-    bool has_style(const std::string &name);
+    bool has_style(const std::string &name) const;
     style &get_style(const std::string &name);
     const style &get_style(const std::string &name) const;
+    std::size_t get_style_id(const std::string &name) const;
     style &create_style(const std::string &name);
+    std::size_t add_style(const style &new_style);
     void clear_styles();
     const std::vector<style> &get_styles() const;
 
@@ -214,10 +220,11 @@ public:
     const std::vector<std::uint8_t> &get_thumbnail() const;
 
 private:
+    friend class excel_serializer;
     friend class worksheet;
-    friend class style_serializer;
     
     std::string next_relationship_id() const;
+    void apply_to_cells(std::function<void(cell)> f);
     
     std::unique_ptr<detail::workbook_impl> d_;
 };
diff --git a/include/xlnt/worksheet/worksheet.hpp b/include/xlnt/worksheet/worksheet.hpp
index 8fef2e8a..14678bfc 100644
--- a/include/xlnt/worksheet/worksheet.hpp
+++ b/include/xlnt/worksheet/worksheet.hpp
@@ -237,6 +237,8 @@ private:
     friend class cell;
     friend class range_iterator;
     friend class const_range_iterator;
+    
+    std::size_t next_custom_number_format_id();
 
     worksheet(detail::worksheet_impl *d);
     detail::worksheet_impl *d_;
diff --git a/source/cell/cell.cpp b/source/cell/cell.cpp
index e77052d0..356a4d87 100644
--- a/source/cell/cell.cpp
+++ b/source/cell/cell.cpp
@@ -31,8 +31,9 @@
 #include <xlnt/packaging/document_properties.hpp>
 #include <xlnt/packaging/relationship.hpp>
 #include <xlnt/serialization/encoding.hpp>
-#include <xlnt/styles/format.hpp>
 #include <xlnt/styles/color.hpp>
+#include <xlnt/styles/format.hpp>
+#include <xlnt/styles/style.hpp>
 #include <xlnt/utils/date.hpp>
 #include <xlnt/utils/datetime.hpp>
 #include <xlnt/utils/time.hpp>
@@ -906,10 +907,24 @@ void cell::set_font(const font &font_)
 
 void cell::set_number_format(const number_format &number_format_)
 {
+    format new_format;
+    
+    if (d_->has_format_)
+    {
+        new_format = get_workbook().get_format(d_->format_id_);
+    }
+    
+    auto number_format_with_id = number_format_;
+    
+    if (!number_format_with_id.has_id())
+    {
+        number_format_with_id.set_id(get_worksheet().next_custom_number_format_id());
+    }
+    
+    new_format.set_number_format(number_format_with_id);
+    
     d_->has_format_ = true;
-    auto format_copy = get_workbook().get_format(d_->format_id_);
-    format_copy.set_number_format(number_format_);
-    d_->format_id_ = get_workbook().add_format(format_copy);
+    d_->format_id_ = get_workbook().add_format(new_format);
 }
 
 void cell::set_alignment(const xlnt::alignment &alignment_)
@@ -1030,4 +1045,42 @@ void cell::guess_type_and_set_value(const std::string &value)
 	}
 }
 
+void cell::clear_format()
+{
+    d_->format_id_ = 0;
+    d_->has_format_ = false;
+}
+
+void cell::clear_style()
+{
+    d_->style_id_ = 0;
+    d_->has_style_ = false;
+}
+
+void cell::set_style(const style &new_style)
+{
+    d_->has_style_ = true;
+
+    if (get_workbook().has_style(new_style.get_name()))
+    {
+        d_->style_id_ = get_workbook().get_style_id(new_style.get_name());
+    }
+    else
+    {
+        d_->style_id_ = get_workbook().add_style(new_style);
+    }
+}
+
+void cell::set_style(const std::string &style_name)
+{
+    d_->has_style_ = true;
+    
+    if (!get_workbook().has_style(style_name))
+    {
+        throw std::runtime_error("style " + style_name + " doesn't exist in workbook");
+    }
+    
+    d_->style_id_ = get_workbook().get_style_id(style_name);
+}
+
 } // namespace xlnt
diff --git a/source/detail/cell_impl.hpp b/source/detail/cell_impl.hpp
index 8b5682d9..56c28474 100644
--- a/source/detail/cell_impl.hpp
+++ b/source/detail/cell_impl.hpp
@@ -72,6 +72,9 @@ struct cell_impl
 
     bool has_format_;
     std::size_t format_id_;
+    
+    bool has_style_;
+    std::size_t style_id_;
 
     std::unique_ptr<comment_impl> comment_;
 };
diff --git a/source/detail/stylesheet.hpp b/source/detail/stylesheet.hpp
new file mode 100644
index 00000000..c0e8f7f3
--- /dev/null
+++ b/source/detail/stylesheet.hpp
@@ -0,0 +1,172 @@
+// Copyright (c) 2014-2016 Thomas Fussell
+// Copyright (c) 2010-2015 openpyxl
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, WRISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE
+//
+// @license: http://www.opensource.org/licenses/mit-license.php
+// @author: see AUTHORS file
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <xlnt/styles/border.hpp>
+#include <xlnt/styles/fill.hpp>
+#include <xlnt/styles/font.hpp>
+#include <xlnt/styles/format.hpp>
+#include <xlnt/styles/number_format.hpp>
+#include <xlnt/styles/style.hpp>
+
+namespace {
+
+template<typename T>
+std::size_t search_vector(const std::vector<T> &items, const T &to_find)
+{
+    auto match = std::find(items.begin(), items.end(), to_find);
+    
+    if (match == items.end())
+    {
+        throw std::out_of_range("xlnt::stylesheet index lookup");
+    }
+    
+    return std::distance(items.begin(), match);
+}
+
+} // namespace
+
+namespace xlnt {
+namespace detail {
+
+struct stylesheet
+{
+    ~stylesheet() {}
+    
+    std::size_t index(const format &f) { return search_vector(formats, f); }
+    
+    std::size_t index(const std::string &style_name)
+    {
+        auto match = std::find_if(styles.begin(), styles.end(),
+            [&](const style &s) { return s.get_name() == style_name; });
+        
+        if (match == styles.end())
+        {
+            throw std::out_of_range("xlnt::stylesheet style index lookup");
+        }
+        
+        return std::distance(styles.begin(), match);
+    }
+
+    std::size_t index(const border &b) { return search_vector(borders, b); }
+    std::size_t index(const fill &f) { return search_vector(fills, f); }
+    std::size_t index(const font &f) { return search_vector(fonts, f); }
+    std::size_t index(const number_format &f) { return search_vector(number_formats, f); }
+    
+    std::size_t add_format(const format &f)
+    {
+        auto match = std::find(formats.begin(), formats.end(), f);
+        
+        if (match != formats.end())
+        {
+            return std::distance(formats.begin(), match);
+        }
+        
+        auto number_format_match = std::find_if(number_formats.begin(), number_formats.end(), [&](const number_format &nf) { return nf.get_format_string() == f.get_number_format().get_format_string(); });
+        
+        if (number_format_match == number_formats.end() && f.get_number_format().get_id() >= 164)
+        {
+            number_formats.push_back(f.get_number_format());
+        }
+        
+        formats.push_back(f);
+        format_styles.push_back("");
+        
+        try
+        {
+            search_vector(borders, f.get_border());
+        }
+        catch(std::out_of_range)
+        {
+            borders.push_back(f.get_border());
+        }
+
+        try
+        {
+            search_vector(fills, f.get_fill());
+        }
+        catch(std::out_of_range)
+        {
+            fills.push_back(f.get_fill());
+        }
+        
+        try
+        {
+            search_vector(fonts, f.get_font());
+        }
+        catch(std::out_of_range)
+        {
+            fonts.push_back(f.get_font());
+        }
+        
+        if (f.get_number_format().get_id() >= 164)
+        {
+            try
+            {
+                search_vector(number_formats, f.get_number_format());
+            }
+            catch(std::out_of_range)
+            {
+                number_formats.push_back(f.get_number_format());
+            }
+        }
+        
+        return formats.size() - 1;
+    }
+    
+    std::size_t add_style(const style &s)
+    {
+        auto match = std::find(styles.begin(), styles.end(), s);
+        
+        if (match != styles.end())
+        {
+            return std::distance(styles.begin(), match);
+        }
+        
+        styles.push_back(s);
+        return styles.size() - 1;
+    }
+
+    std::vector<format> formats;
+    std::vector<std::string> format_styles;
+    std::vector<style> styles;
+
+    std::vector<border> borders;
+    std::vector<fill> fills;
+    std::vector<font> fonts;
+    std::vector<number_format> number_formats;
+    
+    std::vector<color> colors;
+
+    std::unordered_map<std::size_t, std::string> style_name_map;
+    
+    std::size_t next_custom_format_id = 164;
+};
+
+} // namespace detail
+} // namespace xlnt
diff --git a/source/detail/workbook_impl.hpp b/source/detail/workbook_impl.hpp
index 09e8a158..00888f25 100644
--- a/source/detail/workbook_impl.hpp
+++ b/source/detail/workbook_impl.hpp
@@ -25,7 +25,9 @@
 #include <iterator>
 #include <vector>
 
+#include <detail/stylesheet.hpp>
 #include <detail/worksheet_impl.hpp>
+#include <xlnt/serialization/encoding.hpp>
 #include <xlnt/packaging/app_properties.hpp>
 #include <xlnt/packaging/document_properties.hpp>
 #include <xlnt/packaging/manifest.hpp>
@@ -54,8 +56,7 @@ struct workbook_impl
           guess_types_(other.guess_types_),
           data_only_(other.data_only_),
           read_only_(other.read_only_),
-          formats_(other.formats_),
-          styles_(other.styles_),
+          stylesheet_(other.stylesheet_),
           manifest_(other.manifest_)
     {
     }
@@ -95,9 +96,7 @@ struct workbook_impl
     bool data_only_;
     bool read_only_;
 
-    std::vector<format> formats_;
-    std::vector<style> styles_;
-    std::size_t next_custom_format_id_;
+    stylesheet stylesheet_;
     
     manifest manifest_;
     theme theme_;
diff --git a/source/serialization/excel_serializer.cpp b/source/serialization/excel_serializer.cpp
index eb899e7a..6c7aae88 100644
--- a/source/serialization/excel_serializer.cpp
+++ b/source/serialization/excel_serializer.cpp
@@ -47,6 +47,8 @@
 #include <xlnt/worksheet/worksheet.hpp>
 
 #include <detail/constants.hpp>
+#include <detail/stylesheet.hpp>
+#include <detail/workbook_impl.hpp>
 
 namespace {
 
@@ -144,10 +146,11 @@ bool load_workbook(xlnt::zip_file &archive, bool guess_types, bool data_only, xl
         }
     }
 
-    xlnt::style_serializer style_reader_(wb);
+    xlnt::detail::stylesheet stylesheet;
+    xlnt::style_serializer style_serializer(stylesheet);
 	xlnt::xml_document style_xml;
 	style_xml.from_string(archive.read(xlnt::constants::ArcStyles()));
-    style_reader_.read_stylesheet(style_xml);
+    style_serializer.read_stylesheet(style_xml);
 
     auto sheets_node = root_node.get_child("sheets");
 
@@ -169,7 +172,7 @@ bool load_workbook(xlnt::zip_file &archive, bool guess_types, bool data_only, xl
         xlnt::worksheet_serializer worksheet_serializer(ws);
 		xlnt::xml_document worksheet_xml;
 		worksheet_xml.from_string(archive.read(ws_filename));
-        worksheet_serializer.read_worksheet(worksheet_xml);
+        worksheet_serializer.read_worksheet(worksheet_xml, stylesheet);
     }
 
     if (archive.has_file("docProps/thumbnail.jpeg"))
@@ -264,8 +267,10 @@ void excel_serializer::write_data(bool /*as_template*/)
 
     archive_.writestr(constants::ArcWorkbook(), xml_serializer::serialize(workbook_serializer_.write_workbook()));
 
-    style_serializer style_serializer_(workbook_);
-    archive_.writestr(constants::ArcStyles(), style_serializer_.write_stylesheet().to_string());
+    style_serializer style_serializer(workbook_.d_->stylesheet_);
+    xlnt::xml_document style_xml;
+    style_serializer.write_stylesheet(style_xml);
+    archive_.writestr(constants::ArcStyles(), style_xml.to_string());
 
     manifest_serializer manifest_serializer_(workbook_.get_manifest());
     archive_.writestr(constants::ArcContentTypes(), manifest_serializer_.write_manifest().to_string());
@@ -329,4 +334,9 @@ bool excel_serializer::save_virtual_workbook(std::vector<std::uint8_t> &bytes, b
     return true;
 }
 
+detail::stylesheet &excel_serializer::get_stylesheet()
+{
+    return workbook_.d_->stylesheet_;
+}
+
 } // namespace xlnt
diff --git a/source/serialization/style_serializer.cpp b/source/serialization/style_serializer.cpp
index daaba483..3a063861 100644
--- a/source/serialization/style_serializer.cpp
+++ b/source/serialization/style_serializer.cpp
@@ -21,11 +21,14 @@
 //
 // @license: http://www.opensource.org/licenses/mit-license.php
 // @author: see AUTHORS file
+
 #include <cctype> // for std::tolower
 #include <unordered_set>
+#include <utility> // for std::move
 
 #include <xlnt/serialization/style_serializer.hpp>
 #include <detail/workbook_impl.hpp>
+#include <detail/stylesheet.hpp>
 #include <xlnt/cell/cell.hpp>
 #include <xlnt/serialization/xml_document.hpp>
 #include <xlnt/serialization/xml_node.hpp>
@@ -46,6 +49,8 @@
 
 namespace {
 
+// Miscellaneous Functions
+
 bool equals_case_insensitive(const std::string &left, const std::string &right)
 {
     if (left.size() != right.size())
@@ -69,6 +74,8 @@ bool is_true(const std::string &bool_string)
     return bool_string == "1" || bool_string == "true";
 }
 
+// Enumerations from string
+
 xlnt::protection::type protection_type_from_string(const std::string &type_string)
 {
     if (equals_case_insensitive(type_string, "true"))
@@ -111,10 +118,22 @@ xlnt::font::underline_style underline_style_from_string(const std::string &under
 
 xlnt::fill::pattern_type pattern_fill_type_from_string(const std::string &fill_type)
 {
-    if (equals_case_insensitive(fill_type, "none")) return xlnt::fill::pattern_type::none;
-    if (equals_case_insensitive(fill_type, "solid")) return xlnt::fill::pattern_type::solid;
-    if (equals_case_insensitive(fill_type, "gray125")) return xlnt::fill::pattern_type::gray125;
-    return xlnt::fill::pattern_type::none;
+    if (equals_case_insensitive(fill_type, "none") || fill_type.empty())
+    {
+        return xlnt::fill::pattern_type::none;
+    }
+    else if (equals_case_insensitive(fill_type, "solid"))
+    {
+        return xlnt::fill::pattern_type::solid;
+    }
+    else if (equals_case_insensitive(fill_type, "gray125"))
+    {
+        return xlnt::fill::pattern_type::gray125;
+    }
+
+    std::string message = "unknown fill type: ";
+    message.append(fill_type);
+    throw std::runtime_error(message);
 };
 
 xlnt::border_style border_style_from_string(const std::string &border_style_string)
@@ -175,55 +194,83 @@ xlnt::border_style border_style_from_string(const std::string &border_style_stri
     {
         return xlnt::border_style::thin;
     }
-    else
-    {
-        std::string message = "unknown border style: ";
-        message.append(border_style_string);
-        throw std::runtime_error(border_style_string);
-    }
+
+    std::string message = "unknown border style: ";
+    message.append(border_style_string);
+    throw std::runtime_error(message);
 }
 
-} // namespace
-
-namespace xlnt {
-
-style_serializer::style_serializer(workbook &wb) : workbook_(wb)
+xlnt::vertical_alignment vertical_alignment_from_string(const std::string &vertical_alignment_string)
 {
-    std::unordered_set<number_format, std::hash<xlnt::hashable>> number_format_set;
-    
-    for (auto ws : workbook_)
+    if (vertical_alignment_string == "bottom")
     {
-        for (auto row : ws.rows())
-        {
-            for (auto cell : row)
-            {
-                if (cell.has_format())
-                {
-                    number_format_set.insert(cell.get_number_format());
-                }
-            }
-        }
+        return xlnt::vertical_alignment::bottom;
     }
-    
-    for (auto nf : number_format_set)
+    else if (vertical_alignment_string == "center")
     {
-        number_formats_.push_back(nf);
+        return xlnt::vertical_alignment::center;
     }
+    else if (vertical_alignment_string == "justify")
+    {
+        return xlnt::vertical_alignment::justify;
+    }
+    else if (vertical_alignment_string == "top")
+    {
+        return xlnt::vertical_alignment::top;
+    }
+
+    std::string message = "unknown vertical alignment: ";
+    message.append(vertical_alignment_string);
+    throw std::runtime_error(message);
 }
 
-protection style_serializer::read_protection(const xml_node &protection_node)
+xlnt::horizontal_alignment horizontal_alignment_from_string(const std::string &horizontal_alignment_string)
 {
-    protection prot;
+    if (horizontal_alignment_string == "left")
+    {
+        return xlnt::horizontal_alignment::left;
+    }
+    else if (horizontal_alignment_string == "center")
+    {
+        return xlnt::horizontal_alignment::center;
+    }
+    else if (horizontal_alignment_string == "center-continuous")
+    {
+        return xlnt::horizontal_alignment::center_continuous;
+    }
+    else if (horizontal_alignment_string == "right")
+    {
+        return xlnt::horizontal_alignment::right;
+    }
+    else if (horizontal_alignment_string == "justify")
+    {
+        return xlnt::horizontal_alignment::justify;
+    }
+    else if (horizontal_alignment_string == "general")
+    {
+        return xlnt::horizontal_alignment::general;
+    }
+
+    std::string message = "unknown horizontal alignment: ";
+    message.append(horizontal_alignment_string);
+    throw std::runtime_error(message);
+}
+
+// Reading
+
+xlnt::protection read_protection(const xlnt::xml_node &protection_node)
+{
+    xlnt::protection prot;
 
     prot.set_locked(protection_type_from_string(protection_node.get_attribute("locked")));
     prot.set_hidden(protection_type_from_string(protection_node.get_attribute("hidden")));
 
-    return prot;
+    return std::move(prot);
 }
 
-alignment style_serializer::read_alignment(const xml_node &alignment_node)
+xlnt::alignment read_alignment(const xlnt::xml_node &alignment_node)
 {
-    alignment align;
+    xlnt::alignment align;
 
     align.set_wrap_text(is_true(alignment_node.get_attribute("wrapText")));
     align.set_shrink_to_fit(is_true(alignment_node.get_attribute("shrinkToFit")));
@@ -233,27 +280,7 @@ alignment style_serializer::read_alignment(const xml_node &alignment_node)
     if (has_vertical)
     {
         std::string vertical = alignment_node.get_attribute("vertical");
-
-        if (vertical == "bottom")
-        {
-            align.set_vertical(vertical_alignment::bottom);
-        }
-        else if (vertical == "center")
-        {
-            align.set_vertical(vertical_alignment::center);
-        }
-        else if (vertical == "justify")
-        {
-            align.set_vertical(vertical_alignment::justify);
-        }
-        else if (vertical == "top")
-        {
-            align.set_vertical(vertical_alignment::top);
-        }
-        else
-        {
-            throw "unknown alignment";
-        }
+        align.set_vertical(vertical_alignment_from_string(vertical));
     }
 
     bool has_horizontal = alignment_node.has_attribute("horizontal");
@@ -261,230 +288,16 @@ alignment style_serializer::read_alignment(const xml_node &alignment_node)
     if (has_horizontal)
     {
         std::string horizontal = alignment_node.get_attribute("horizontal");
-
-        if (horizontal == "left")
-        {
-            align.set_horizontal(horizontal_alignment::left);
-        }
-        else if (horizontal == "center")
-        {
-            align.set_horizontal(horizontal_alignment::center);
-        }
-        else if (horizontal == "center-continuous")
-        {
-            align.set_horizontal(horizontal_alignment::center_continuous);
-        }
-        else if (horizontal == "right")
-        {
-            align.set_horizontal(horizontal_alignment::right);
-        }
-        else if (horizontal == "justify")
-        {
-            align.set_horizontal(horizontal_alignment::justify);
-        }
-        else if (horizontal == "general")
-        {
-            align.set_horizontal(horizontal_alignment::general);
-        }
-        else
-        {
-            throw "unknown alignment";
-        }
+        align.set_horizontal(horizontal_alignment_from_string(horizontal));
     }
 
     return align;
 }
 
-format style_serializer::read_format(const xml_node &format_node)
+void read_number_formats(const xlnt::xml_node &number_formats_node, std::vector<xlnt::number_format> &number_formats)
 {
-    format f;
-    
-    // Alignment
-    f.alignment_applied(format_node.has_child("alignment") || is_true(format_node.get_attribute("applyAlignment")));
+    number_formats.clear();
 
-    if (f.alignment_applied())
-    {
-        auto inline_alignment = read_alignment(format_node.get_child("alignment"));
-        f.set_alignment(inline_alignment);
-    }
-    
-    // Border
-    auto border_index = format_node.has_attribute("borderId") ? std::stoull(format_node.get_attribute("borderId")) : 0;
-    f.set_border(borders_.at(border_index));
-    f.border_applied(is_true(format_node.get_attribute("applyBorder")));
-    
-    // Fill
-    auto fill_index = format_node.has_attribute("fillId") ? std::stoull(format_node.get_attribute("fillId")) : 0;
-    f.set_fill(fills_.at(fill_index));
-    f.fill_applied(is_true(format_node.get_attribute("applyFill")));
-    
-    // Font
-    auto font_index = format_node.has_attribute("fontId") ? std::stoull(format_node.get_attribute("fontId")) : 0;
-    f.set_font(fonts_.at(font_index));
-    f.font_applied(is_true(format_node.get_attribute("applyFont")));
-
-    // Number Format
-    auto number_format_id = std::stoull(format_node.get_attribute("numFmtId"));
-
-    bool builtin_format = true;
-
-    for (const auto &num_fmt : number_formats_)
-    {
-        if (static_cast<std::size_t>(num_fmt.get_id()) == number_format_id)
-        {
-            f.set_number_format(num_fmt);
-            builtin_format = false;
-            break;
-        }
-    }
-
-    if (builtin_format)
-    {
-        f.set_number_format(number_format::from_builtin_id(number_format_id));
-    }
-    
-    f.number_format_applied(is_true(format_node.get_attribute("applyNumberFormat")));
-
-    // Protection
-    f.protection_applied(format_node.has_attribute("protection") || is_true(format_node.get_attribute("applyProtection")));
-
-    if (f.protection_applied())
-    {
-        auto inline_protection = read_protection(format_node.get_child("protection"));
-        f.set_protection(inline_protection);
-    }
-
-    return f;
-}
-
-style style_serializer::read_style(const xml_node &style_node, const xml_node &style_format_node)
-{
-    style s;
-
-    s.set_name(style_node.get_attribute("name"));
-    s.set_hidden(style_node.has_attribute("hidden") && is_true(style_node.get_attribute("hidden")));
-    s.set_builtin_id(std::stoull(style_node.get_attribute("builtinId")));
-    
-    auto base_style = read_format(style_format_node);
-    
-    //TODO shouldn't have to set apply after set_X()
-    s.set_alignment(base_style.get_alignment());
-    s.alignment_applied(base_style.alignment_applied());
-    s.set_border(base_style.get_border());
-    s.border_applied(base_style.border_applied());
-    s.set_fill(base_style.get_fill());
-    s.fill_applied(base_style.fill_applied());
-    s.set_font(base_style.get_font());
-    s.font_applied(base_style.font_applied());
-    s.set_number_format(base_style.get_number_format());
-    s.number_format_applied(base_style.number_format_applied());
-    s.set_protection(base_style.get_protection());
-    s.protection_applied(base_style.protection_applied());
-    
-    return s;
-}
-
-bool style_serializer::read_stylesheet(const xml_document &xml)
-{
-    auto stylesheet_node = xml.get_child("styleSheet");
-
-    read_borders(stylesheet_node.get_child("borders"));
-    read_fills(stylesheet_node.get_child("fills"));
-    read_fonts(stylesheet_node.get_child("fonts"));
-    read_number_formats(stylesheet_node.get_child("numFmts"));
-    read_colors(stylesheet_node.get_child("colors"));
-    read_styles(stylesheet_node.get_child("cellStyles"), stylesheet_node.get_child("cellStyleXfs"));
-    read_formats(stylesheet_node.get_child("cellXfs"));
-
-    if (!styles_.empty())
-    {
-        workbook_.clear_styles();
-    }
-
-    for (const auto &ns : styles_)
-    {
-        workbook_.create_style(ns.get_name()) = ns;
-    }
-    
-    if (!formats_.empty())
-    {
-        workbook_.clear_formats();
-    }
-    
-    for (const auto &s : formats_)
-    {
-        workbook_.d_->formats_.push_back(s);
-    }
-
-    return true;
-}
-
-bool style_serializer::read_formats(const xlnt::xml_node &formats_node)
-{
-    for (auto format_node : formats_node.get_children())
-    {
-        if (format_node.get_name() != "xf")
-        {
-            continue;
-        }
-
-        auto cell_format = read_format(format_node);
-        
-        // TODO do all formats have xfId?
-        if(format_node.has_attribute("xfId"))
-        {
-            auto style_index = std::stoull(format_node.get_attribute("xfId"));
-            auto cell_style = styles_.at(style_index);
-            
-            cell_format.set_style(cell_style.get_name());
-        }
-        
-        formats_.push_back(cell_format);
-    }
-    
-    return true;
-}
-
-bool style_serializer::read_styles(const xlnt::xml_node &styles_node, const xlnt::xml_node &style_formats_node)
-{
-    std::size_t style_index = 0;
-    
-    for (auto cell_style_format_node : style_formats_node.get_children())
-    {
-        bool match = false;
-        style ns;
-        
-        for (auto cell_style_node : styles_node.get_children())
-        {
-            auto cell_style_format_index = std::stoull(cell_style_node.get_attribute("xfId"));
-            
-            if (cell_style_format_index == style_index)
-            {
-                ns = read_style(cell_style_node, cell_style_format_node);
-                match = true;
-                
-                break;
-            }
-        }
-        
-        styles_.push_back(ns);
-        style_index++;
-    }
-    
-    if (styles_.empty())
-    {
-        style ns;
-        ns.set_name("Normal");
-        ns.set_hidden(false);
-        ns.set_builtin_id(0);
-        styles_.push_back(ns);
-    }
-    
-    return true;
-}
-
-bool style_serializer::read_number_formats(const xml_node &number_formats_node)
-{
     for (auto num_fmt_node : number_formats_node.get_children())
     {
         if (num_fmt_node.get_name() != "numFmt")
@@ -499,35 +312,40 @@ bool style_serializer::read_number_formats(const xml_node &number_formats_node)
             format_string = "General";
         }
 
-        number_format nf;
+        xlnt::number_format nf;
 
         nf.set_format_string(format_string);
         nf.set_id(std::stoull(num_fmt_node.get_attribute("numFmtId")));
 
-        number_formats_.push_back(nf);
+        number_formats.push_back(nf);
     }
-    
-    if (number_formats_.empty())
-    {
-        number_formats_.push_back(number_format::general());
-    }
-
-    return true;
 }
 
-bool style_serializer::read_fonts(const xml_node &fonts_node)
+xlnt::color read_color(const xlnt::xml_node &color_node)
 {
-    for (auto font_node : fonts_node.get_children())
+    if (color_node.has_attribute("rgb"))
     {
-        fonts_.push_back(read_font(font_node));
+        return xlnt::color(xlnt::color::type::rgb, color_node.get_attribute("rgb"));
+    }
+    else if (color_node.has_attribute("theme"))
+    {
+        return xlnt::color(xlnt::color::type::theme, std::stoull(color_node.get_attribute("theme")));
+    }
+    else if (color_node.has_attribute("indexed"))
+    {
+        return xlnt::color(xlnt::color::type::indexed, std::stoull(color_node.get_attribute("indexed")));
+    }
+    else if (color_node.has_attribute("auto"))
+    {
+        return xlnt::color(xlnt::color::type::auto_, std::stoull(color_node.get_attribute("auto")));
     }
 
-    return true;
+    throw std::runtime_error("bad color");
 }
 
-font style_serializer::read_font(const xlnt::xml_node &font_node)
+xlnt::font read_font(const xlnt::xml_node &font_node)
 {
-    font new_font;
+    xlnt::font new_font;
 
     new_font.set_size(std::stoull(font_node.get_child("sz").get_attribute("val")));
     new_font.set_name(font_node.get_child("name").get_attribute("val"));
@@ -599,38 +417,41 @@ font style_serializer::read_font(const xlnt::xml_node &font_node)
     return new_font;
 }
 
-bool style_serializer::read_colors(const xml_node &colors_node)
+void read_fonts(const xlnt::xml_node &fonts_node, std::vector<xlnt::font> &fonts)
 {
+    fonts.clear();
+
+    for (auto font_node : fonts_node.get_children())
+    {
+        fonts.push_back(read_font(font_node));
+    }
+}
+
+void read_indexed_colors(const xlnt::xml_node &indexed_colors_node, std::vector<xlnt::color> &colors)
+{
+    for (auto color_node : indexed_colors_node.get_children())
+    {
+        colors.push_back(read_color(color_node));
+    }
+}
+
+void read_colors(const xlnt::xml_node &colors_node, std::vector<xlnt::color> &colors)
+{
+    colors.clear();
+
     if (colors_node.has_child("indexedColors"))
     {
-        auto indexed_colors = read_indexed_colors(colors_node.get_child("indexedColors"));
-
-        for (const auto &indexed_color : indexed_colors)
-        {
-            colors_.push_back(indexed_color);
-        }
+        read_indexed_colors(colors_node.get_child("indexedColors"), colors);
     }
-
-    return true;
 }
 
-bool style_serializer::read_fills(const xml_node &fills_node)
+xlnt::fill read_fill(const xlnt::xml_node &fill_node)
 {
-    for (auto fill_node : fills_node.get_children())
-    {
-        fills_.push_back(read_fill(fill_node));
-    }
-
-    return true;
-}
-
-fill style_serializer::read_fill(const xml_node &fill_node)
-{
-    fill new_fill;
+    xlnt::fill new_fill;
 
     if (fill_node.has_child("patternFill"))
     {
-        new_fill.set_type(fill::type::pattern);
+        new_fill.set_type(xlnt::fill::type::pattern);
 
         auto pattern_fill_node = fill_node.get_child("patternFill");
         new_fill.set_pattern_type(pattern_fill_type_from_string(pattern_fill_node.get_attribute("patternType")));
@@ -649,9 +470,20 @@ fill style_serializer::read_fill(const xml_node &fill_node)
     return new_fill;
 }
 
-side style_serializer::read_side(const xml_node &side_node)
+void read_fills(const xlnt::xml_node &fills_node, std::vector<xlnt::fill> &fills)
 {
-    side new_side;
+    fills.clear();
+
+    for (auto fill_node : fills_node.get_children())
+    {
+        fills.emplace_back();
+        fills.back() = read_fill(fill_node);
+    }
+}
+
+xlnt::side read_side(const xlnt::xml_node &side_node)
+{
+    xlnt::side new_side;
 
     if (side_node.has_attribute("style"))
     {
@@ -666,19 +498,9 @@ side style_serializer::read_side(const xml_node &side_node)
     return new_side;
 }
 
-bool style_serializer::read_borders(const xml_node &borders_node)
+xlnt::border read_border(const xlnt::xml_node &border_node)
 {
-    for (auto border_node : borders_node.get_children())
-    {
-        borders_.push_back(read_border(border_node));
-    }
-
-    return true;
-}
-
-border style_serializer::read_border(const xml_node &border_node)
-{
-    border new_border;
+    xlnt::border new_border;
 
     if (border_node.has_child("start"))
     {
@@ -728,98 +550,153 @@ border style_serializer::read_border(const xml_node &border_node)
     return new_border;
 }
 
-std::vector<color> style_serializer::read_indexed_colors(const xml_node &indexed_colors_node)
+void read_borders(const xlnt::xml_node &borders_node, std::vector<xlnt::border> &borders)
 {
-    std::vector<color> colors;
+    borders.clear();
 
-    for (auto color_node : indexed_colors_node.get_children())
+    for (auto border_node : borders_node.get_children())
     {
-        colors.push_back(read_color(color_node));
-    }
-
-    return colors;
-}
-
-color style_serializer::read_color(const xml_node &color_node)
-{
-    if (color_node.has_attribute("rgb"))
-    {
-        return color(color::type::rgb, color_node.get_attribute("rgb"));
-    }
-    else if (color_node.has_attribute("theme"))
-    {
-        return color(color::type::theme, std::stoull(color_node.get_attribute("theme")));
-    }
-    else if (color_node.has_attribute("indexed"))
-    {
-        return color(color::type::indexed, std::stoull(color_node.get_attribute("indexed")));
-    }
-    else if (color_node.has_attribute("auto"))
-    {
-        return color(color::type::auto_, std::stoull(color_node.get_attribute("auto")));
-    }
-
-    throw std::runtime_error("bad color");
-}
-
-void style_serializer::initialize_vectors()
-{
-    formats_.assign(workbook_.get_formats().begin(), workbook_.get_formats().end());
-    colors_.clear();
-    borders_.clear();
-    fills_.clear();
-    fonts_.clear();
-    number_formats_.clear();
-    
-    for (auto &current_format : formats_)
-    {
-        if (std::find(borders_.begin(), borders_.end(), current_format.get_border()) == borders_.end())
-        {
-            borders_.push_back(current_format.get_border());
-        }
-        
-        if (std::find(fills_.begin(), fills_.end(), current_format.get_fill()) == fills_.end())
-        {
-            fills_.push_back(current_format.get_fill());
-        }
-        
-        if (std::find(fonts_.begin(), fonts_.end(), current_format.get_font()) == fonts_.end())
-        {
-            fonts_.push_back(current_format.get_font());
-        }
-        
-        if (std::find(number_formats_.begin(), number_formats_.end(), current_format.get_number_format()) == number_formats_.end())
-        {
-            number_formats_.push_back(current_format.get_number_format());
-        }
-        
-        auto existing_style = std::find_if(styles_.begin(), styles_.end(),
-            [&current_format](const style &s) { return s.get_name() == current_format.get_style_name(); });
-
-        if (existing_style == styles_.end())
-        {
-            styles_.push_back(workbook_.get_style(current_format.get_style_name()));
-        }
-    }
-    
-    if (fonts_.empty())
-    {
-        fonts_.push_back(font());
-    }
-    
-    if (number_formats_.empty())
-    {
-        number_formats_.push_back(number_format::general());
+        borders.push_back(read_border(border_node));
     }
 }
 
-bool style_serializer::write_fonts(xlnt::xml_node &fonts_node) const
+
+bool read_base_format(const xlnt::xml_node &format_node, const xlnt::detail::stylesheet &stylesheet, xlnt::base_format &f)
 {
-    fonts_node.add_attribute("count", std::to_string(fonts_.size()));
+    // Alignment
+    f.alignment_applied(format_node.has_child("alignment") || is_true(format_node.get_attribute("applyAlignment")));
+
+    if (f.alignment_applied())
+    {
+        auto inline_alignment = read_alignment(format_node.get_child("alignment"));
+        f.set_alignment(inline_alignment);
+    }
+    
+    // Border
+    auto border_index = format_node.has_attribute("borderId") ? std::stoull(format_node.get_attribute("borderId")) : 0;
+    f.set_border(stylesheet.borders.at(border_index));
+    f.border_applied(is_true(format_node.get_attribute("applyBorder")));
+    
+    // Fill
+    auto fill_index = format_node.has_attribute("fillId") ? std::stoull(format_node.get_attribute("fillId")) : 0;
+    f.set_fill(stylesheet.fills.at(fill_index));
+    f.fill_applied(is_true(format_node.get_attribute("applyFill")));
+    
+    // Font
+    auto font_index = format_node.has_attribute("fontId") ? std::stoull(format_node.get_attribute("fontId")) : 0;
+    f.set_font(stylesheet.fonts.at(font_index));
+    f.font_applied(is_true(format_node.get_attribute("applyFont")));
+
+    // Number Format
+    auto number_format_id = std::stoull(format_node.get_attribute("numFmtId"));
+
+    bool builtin_format = true;
+
+    for (const auto &num_fmt : stylesheet.number_formats)
+    {
+        if (static_cast<std::size_t>(num_fmt.get_id()) == number_format_id)
+        {
+            f.set_number_format(num_fmt);
+            builtin_format = false;
+            break;
+        }
+    }
+
+    if (builtin_format)
+    {
+        f.set_number_format(xlnt::number_format::from_builtin_id(number_format_id));
+    }
+    
+    f.number_format_applied(is_true(format_node.get_attribute("applyNumberFormat")));
+
+    // Protection
+    f.protection_applied(format_node.has_attribute("protection") || is_true(format_node.get_attribute("applyProtection")));
+
+    if (f.protection_applied())
+    {
+        auto inline_protection = read_protection(format_node.get_child("protection"));
+        f.set_protection(inline_protection);
+    }
+    
+    return true;
+}
+
+
+void read_formats(const xlnt::xml_node &formats_node, const xlnt::detail::stylesheet &stylesheet,
+    std::vector<xlnt::format> &formats, std::vector<std::string> &format_styles)
+{
+    for (auto format_node : formats_node.get_children())
+    {
+        if (format_node.get_name() != "xf")
+        {
+            continue;
+        }
+
+        xlnt::format format;
+        read_base_format(format_node, stylesheet, format);
+        
+        // TODO do all formats have xfId?
+        if(format_node.has_attribute("xfId"))
+        {
+            auto style_index = std::stoull(format_node.get_attribute("xfId"));
+            auto style_name = stylesheet.style_name_map.at(style_index);
+            format_styles.push_back(style_name);
+        }
+        else
+        {
+            format_styles.push_back("");
+        }
+        
+        formats.push_back(format);
+    }
+}
+
+xlnt::style read_style(const xlnt::xml_node &style_node, const xlnt::xml_node &style_format_node, const xlnt::detail::stylesheet &stylesheet)
+{
+    xlnt::style s;
+
+    read_base_format(style_format_node, stylesheet, s);
+
+    s.set_name(style_node.get_attribute("name"));
+    s.set_hidden(style_node.has_attribute("hidden") && is_true(style_node.get_attribute("hidden")));
+    s.set_builtin_id(std::stoull(style_node.get_attribute("builtinId")));
+    
+    return s;
+}
+
+void read_styles(const xlnt::xml_node &styles_node, const xlnt::xml_node &style_formats_node, const xlnt::detail::stylesheet stylesheet, std::vector<xlnt::style> &styles, std::unordered_map<std::size_t, std::string> &style_names)
+{
+    std::size_t style_index = 0;
+    
+    for (auto cell_style_format_node : style_formats_node.get_children())
+    {
+        bool match = false;
+        
+        for (auto cell_style_node : styles_node.get_children())
+        {
+            auto cell_style_format_index = std::stoull(cell_style_node.get_attribute("xfId"));
+            
+            if (cell_style_format_index == style_index)
+            {
+                styles.push_back(read_style(cell_style_node, cell_style_format_node, stylesheet));
+                style_names[style_index] = styles.back().get_name();
+                match = true;
+                
+                break;
+            }
+        }
+
+        style_index++;
+    }
+}
+
+bool write_fonts(const std::vector<xlnt::font> &fonts, xlnt::xml_node &fonts_node)
+{
+    fonts_node.add_attribute("count", std::to_string(fonts.size()));
     // TODO: what does this do?
     // fonts_node.add_attribute("x14ac:knownFonts", "1");
 
-    for (auto &f : fonts_)
+    for (auto &f : fonts)
     {
         auto font_node = fonts_node.add_child("font");
 
@@ -841,7 +718,7 @@ bool style_serializer::write_fonts(xlnt::xml_node &fonts_node) const
 
             switch (f.get_underline())
             {
-            case font::underline_style::single:
+            case xlnt::font::underline_style::single:
                 underline_node.add_attribute("val", "single");
                 break;
             default:
@@ -860,19 +737,19 @@ bool style_serializer::write_fonts(xlnt::xml_node &fonts_node) const
 
         auto color_node = font_node.add_child("color");
 
-        if (f.get_color().get_type() == color::type::indexed)
+        if (f.get_color().get_type() == xlnt::color::type::indexed)
         {
             color_node.add_attribute("indexed", std::to_string(f.get_color().get_index()));
         }
-        else if (f.get_color().get_type() == color::type::theme)
+        else if (f.get_color().get_type() == xlnt::color::type::theme)
         {
             color_node.add_attribute("theme", std::to_string(f.get_color().get_theme()));
         }
-        else if (f.get_color().get_type() == color::type::auto_)
+        else if (f.get_color().get_type() == xlnt::color::type::auto_)
         {
             color_node.add_attribute("auto", std::to_string(f.get_color().get_auto()));
         }
-        else if (f.get_color().get_type() == color::type::rgb)
+        else if (f.get_color().get_type() == xlnt::color::type::rgb)
         {
             color_node.add_attribute("rgb", f.get_color().get_rgb_string());
         }
@@ -896,15 +773,15 @@ bool style_serializer::write_fonts(xlnt::xml_node &fonts_node) const
     return true;
 }
 
-bool style_serializer::write_fills(xlnt::xml_node &fills_node) const
+bool write_fills(const std::vector<xlnt::fill> &fills, xlnt::xml_node &fills_node)
 {
-    fills_node.add_attribute("count", std::to_string(fills_.size()));
+    fills_node.add_attribute("count", std::to_string(fills.size()));
 
-    for (auto &fill_ : fills_)
+    for (auto &fill_ : fills)
     {
         auto fill_node = fills_node.add_child("fill");
 
-        if (fill_.get_type() == fill::type::pattern)
+        if (fill_.get_type() == xlnt::fill::type::pattern)
         {
             auto pattern_fill_node = fill_node.add_child("patternFill");
             auto type_string = fill_.get_pattern_type_string();
@@ -918,16 +795,16 @@ bool style_serializer::write_fills(xlnt::xml_node &fills_node) const
 
                 switch (fill_.get_foreground_color()->get_type())
                 {
-                case color::type::auto_:
+                case xlnt::color::type::auto_:
                     fg_color_node.add_attribute("auto", std::to_string(fill_.get_foreground_color()->get_auto()));
                     break;
-                case color::type::theme:
+                case xlnt::color::type::theme:
                     fg_color_node.add_attribute("theme", std::to_string(fill_.get_foreground_color()->get_theme()));
                     break;
-                case color::type::indexed:
+                case xlnt::color::type::indexed:
                     fg_color_node.add_attribute("indexed", std::to_string(fill_.get_foreground_color()->get_index()));
                     break;
-                case color::type::rgb:
+                case xlnt::color::type::rgb:
                     fg_color_node.add_attribute("rgb", fill_.get_foreground_color()->get_rgb_string());
                     break;
                 default:
@@ -941,16 +818,16 @@ bool style_serializer::write_fills(xlnt::xml_node &fills_node) const
 
                 switch (fill_.get_background_color()->get_type())
                 {
-                case color::type::auto_:
+                case xlnt::color::type::auto_:
                     bg_color_node.add_attribute("auto", std::to_string(fill_.get_background_color()->get_auto()));
                     break;
-                case color::type::theme:
+                case xlnt::color::type::theme:
                     bg_color_node.add_attribute("theme", std::to_string(fill_.get_background_color()->get_theme()));
                     break;
-                case color::type::indexed:
+                case xlnt::color::type::indexed:
                     bg_color_node.add_attribute("indexed", std::to_string(fill_.get_background_color()->get_index()));
                     break;
-                case color::type::rgb:
+                case xlnt::color::type::rgb:
                     bg_color_node.add_attribute("rgb", fill_.get_background_color()->get_rgb_string());
                     break;
                 default:
@@ -958,12 +835,12 @@ bool style_serializer::write_fills(xlnt::xml_node &fills_node) const
                 }
             }
         }
-        else if (fill_.get_type() == fill::type::solid)
+        else if (fill_.get_type() == xlnt::fill::type::solid)
         {
             auto solid_fill_node = fill_node.add_child("solidFill");
             solid_fill_node.add_child("color");
         }
-        else if (fill_.get_type() == fill::type::gradient)
+        else if (fill_.get_type() == xlnt::fill::type::gradient)
         {
             auto gradient_fill_node = fill_node.add_child("gradientFill");
 
@@ -990,15 +867,15 @@ bool style_serializer::write_fills(xlnt::xml_node &fills_node) const
     return true;
 }
 
-bool style_serializer::write_borders(xlnt::xml_node &borders_node) const
+bool write_borders(const std::vector<xlnt::border> &borders, xlnt::xml_node &borders_node)
 {
-    borders_node.add_attribute("count", std::to_string(borders_.size()));
+    borders_node.add_attribute("count", std::to_string(borders.size()));
 
-    for (const auto &border_ : borders_)
+    for (const auto &border_ : borders)
     {
         auto border_node = borders_node.add_child("border");
 
-        std::vector<std::tuple<std::string, const std::experimental::optional<side>>> sides;
+        std::vector<std::tuple<std::string, const std::experimental::optional<xlnt::side>>> sides;
         
         sides.push_back(std::make_tuple("start", border_.get_start()));
         sides.push_back(std::make_tuple("end", border_.get_end()));
@@ -1025,46 +902,46 @@ bool style_serializer::write_borders(xlnt::xml_node &borders_node) const
 
                     switch (*current_side->get_border_style())
                     {
-                    case border_style::none:
+                    case xlnt::border_style::none:
                         style_string = "none";
                         break;
-                    case border_style::dashdot:
+                    case xlnt::border_style::dashdot:
                         style_string = "dashDot";
                         break;
-                    case border_style::dashdotdot:
+                    case xlnt::border_style::dashdotdot:
                         style_string = "dashDotDot";
                         break;
-                    case border_style::dashed:
+                    case xlnt::border_style::dashed:
                         style_string = "dashed";
                         break;
-                    case border_style::dotted:
+                    case xlnt::border_style::dotted:
                         style_string = "dotted";
                         break;
-                    case border_style::double_:
+                    case xlnt::border_style::double_:
                         style_string = "double";
                         break;
-                    case border_style::hair:
+                    case xlnt::border_style::hair:
                         style_string = "hair";
                         break;
-                    case border_style::medium:
+                    case xlnt::border_style::medium:
                         style_string = "thin";
                         break;
-                    case border_style::mediumdashdot:
+                    case xlnt::border_style::mediumdashdot:
                         style_string = "mediumDashDot";
                         break;
-                    case border_style::mediumdashdotdot:
+                    case xlnt::border_style::mediumdashdotdot:
                         style_string = "mediumDashDotDot";
                         break;
-                    case border_style::mediumdashed:
+                    case xlnt::border_style::mediumdashed:
                         style_string = "mediumDashed";
                         break;
-                    case border_style::slantdashdot:
+                    case xlnt::border_style::slantdashdot:
                         style_string = "slantDashDot";
                         break;
-                    case border_style::thick:
+                    case xlnt::border_style::thick:
                         style_string = "thick";
                         break;
-                    case border_style::thin:
+                    case xlnt::border_style::thin:
                         style_string = "thin";
                         break;
                     default:
@@ -1078,15 +955,15 @@ bool style_serializer::write_borders(xlnt::xml_node &borders_node) const
                 {
                     auto color_node = side_node.add_child("color");
 
-                    if (current_side->get_color()->get_type() == color::type::indexed)
+                    if (current_side->get_color()->get_type() == xlnt::color::type::indexed)
                     {
                         color_node.add_attribute("indexed", std::to_string(current_side->get_color()->get_index()));
                     }
-                    else if (current_side->get_color()->get_type() == color::type::theme)
+                    else if (current_side->get_color()->get_type() == xlnt::color::type::theme)
                     {
                         color_node.add_attribute("theme", std::to_string(current_side->get_color()->get_theme()));
                     }
-                    else if (current_side->get_color()->get_type() == color::type::rgb)
+                    else if (current_side->get_color()->get_type() == xlnt::color::type::rgb)
                     {
                         color_node.add_attribute("rgb", current_side->get_color()->get_rgb_string());
                     }
@@ -1102,17 +979,17 @@ bool style_serializer::write_borders(xlnt::xml_node &borders_node) const
     return true;
 }
 
-bool style_serializer::write_formattable(const formattable &xf, xml_node xf_node) const
+bool write_base_format(const xlnt::base_format &xf, const xlnt::detail::stylesheet &stylesheet, xlnt::xml_node xf_node)
 {
     xf_node.add_attribute("numFmtId", std::to_string(xf.get_number_format().get_id()));
      
-    auto font_id = std::distance(fonts_.begin(), std::find(fonts_.begin(), fonts_.end(), xf.get_font()));
+    auto font_id = std::distance(stylesheet.fonts.begin(), std::find(stylesheet.fonts.begin(), stylesheet.fonts.end(), xf.get_font()));
     xf_node.add_attribute("fontId", std::to_string(font_id));
 
-    auto fill_id = std::distance(fills_.begin(), std::find(fills_.begin(), fills_.end(), xf.get_fill()));
+    auto fill_id = std::distance(stylesheet.fills.begin(), std::find(stylesheet.fills.begin(), stylesheet.fills.end(), xf.get_fill()));
     xf_node.add_attribute("fillId", std::to_string(fill_id));
 
-    auto border_id = std::distance(borders_.begin(), std::find(borders_.begin(), borders_.end(), xf.get_border()));
+    auto border_id = std::distance(stylesheet.borders.begin(), std::find(stylesheet.borders.begin(), stylesheet.borders.end(), xf.get_border()));
     xf_node.add_attribute("borderId", std::to_string(border_id));
 
     if(xf.number_format_applied()) xf_node.add_attribute("applyNumberFormat", "1");
@@ -1130,16 +1007,16 @@ bool style_serializer::write_formattable(const formattable &xf, xml_node xf_node
         {
             switch (xf.get_alignment().get_vertical())
             {
-            case vertical_alignment::bottom:
+            case xlnt::vertical_alignment::bottom:
                 alignment_node.add_attribute("vertical", "bottom");
                 break;
-            case vertical_alignment::center:
+            case xlnt::vertical_alignment::center:
                 alignment_node.add_attribute("vertical", "center");
                 break;
-            case vertical_alignment::justify:
+            case xlnt::vertical_alignment::justify:
                 alignment_node.add_attribute("vertical", "justify");
                 break;
-            case vertical_alignment::top:
+            case xlnt::vertical_alignment::top:
                 alignment_node.add_attribute("vertical", "top");
                 break;
             default:
@@ -1151,22 +1028,22 @@ bool style_serializer::write_formattable(const formattable &xf, xml_node xf_node
         {
             switch (xf.get_alignment().get_horizontal())
             {
-            case horizontal_alignment::center:
+            case xlnt::horizontal_alignment::center:
                 alignment_node.add_attribute("horizontal", "center");
                 break;
-            case horizontal_alignment::center_continuous:
+            case xlnt::horizontal_alignment::center_continuous:
                 alignment_node.add_attribute("horizontal", "center_continuous");
                 break;
-            case horizontal_alignment::general:
+            case xlnt::horizontal_alignment::general:
                 alignment_node.add_attribute("horizontal", "general");
                 break;
-            case horizontal_alignment::justify:
+            case xlnt::horizontal_alignment::justify:
                 alignment_node.add_attribute("horizontal", "justify");
                 break;
-            case horizontal_alignment::left:
+            case xlnt::horizontal_alignment::left:
                 alignment_node.add_attribute("horizontal", "left");
                 break;
-            case horizontal_alignment::right:
+            case xlnt::horizontal_alignment::right:
                 alignment_node.add_attribute("horizontal", "right");
                 break;
             default:
@@ -1185,21 +1062,21 @@ bool style_serializer::write_formattable(const formattable &xf, xml_node xf_node
         }
     }
     
-    //TODO protection
+    //TODO protection!
     
     return true;
 }
 
-bool style_serializer::write_styles(xml_node &styles_node, xml_node &style_formats_node) const
+bool write_styles(const xlnt::detail::stylesheet &stylesheet, xlnt::xml_node &styles_node, xlnt::xml_node &style_formats_node)
 {
-    style_formats_node.add_attribute("count", std::to_string(styles_.size()));
-    styles_node.add_attribute("count", std::to_string(styles_.size()));
+    style_formats_node.add_attribute("count", std::to_string(stylesheet.styles.size()));
+    styles_node.add_attribute("count", std::to_string(stylesheet.styles.size()));
     std::size_t style_index = 0;
 
-    for(auto &current_style : styles_)
+    for(auto &current_style : stylesheet.styles)
     {
         auto xf_node = style_formats_node.add_child("xf");
-        write_formattable(current_style, xf_node);
+        write_base_format(current_style, stylesheet, xf_node);
 
         auto cell_style_node = styles_node.add_child("cellStyle");
         
@@ -1216,27 +1093,26 @@ bool style_serializer::write_styles(xml_node &styles_node, xml_node &style_forma
     return true;
 }
 
-bool style_serializer::write_formats(xml_node &formats_node) const
+bool write_formats(const xlnt::detail::stylesheet &stylesheet, xlnt::xml_node &formats_node)
 {
-    formats_node.add_attribute("count", std::to_string(formats_.size()));
+    formats_node.add_attribute("count", std::to_string(stylesheet.formats.size()));
 
-    for(auto &current_format : formats_)
+    auto format_style_iterator = stylesheet.format_styles.begin();
+
+    for(auto &current_format : stylesheet.formats)
     {
         auto xf_node = formats_node.add_child("xf");
-        write_formattable(current_format, xf_node);
+        write_base_format(current_format, stylesheet, xf_node);
         
-        if(current_format.has_style())
+        const auto format_style_name = *(format_style_iterator++);
+        
+        if(!format_style_name.empty())
         {
-            for (std::size_t i = 0; i < styles_.size(); i++)
-            {
-                const auto &current_style = styles_.at(i);
-                
-                if (current_style.get_name() == current_format.get_style_name())
-                {
-                    xf_node.add_attribute("xfId", std::to_string(i));
-                    break;
-                }
-            }
+            auto style = std::find_if(stylesheet.styles.begin(), stylesheet.styles.end(),
+                [&](const xlnt::style &s) { return s.get_name() == format_style_name; });
+            auto style_index = std::distance(stylesheet.styles.begin(), style);
+            
+            xf_node.add_attribute("xfId", std::to_string(style_index));
         }
     }
 
@@ -1258,11 +1134,11 @@ bool write_table_styles(xlnt::xml_node &table_styles_node)
     return true;
 }
 
-bool style_serializer::write_colors(xlnt::xml_node &colors_node) const
+bool write_colors(const std::vector<xlnt::color> &colors, xlnt::xml_node &colors_node)
 {
     auto indexed_colors_node = colors_node.add_child("indexedColors");
 
-    for (auto &c : colors_)
+    for (auto &c : colors)
     {
         indexed_colors_node.add_child("rgbColor").add_attribute("rgb", c.get_rgb_string());
     }
@@ -1270,7 +1146,7 @@ bool style_serializer::write_colors(xlnt::xml_node &colors_node) const
     return true;
 }
 
-bool style_serializer::write_ext_list(xlnt::xml_node &ext_list_node) const
+bool write_ext_list(xlnt::xml_node &ext_list_node)
 {
     auto ext_node = ext_list_node.add_child("ext");
     ext_node.add_attribute("uri", "{EB79DEF2-80B8-43e5-95BD-54CBDDF9020C}");
@@ -1280,63 +1156,11 @@ bool style_serializer::write_ext_list(xlnt::xml_node &ext_list_node) const
     return true;
 }
 
-xml_document style_serializer::write_stylesheet()
+bool write_number_formats(const std::vector<xlnt::number_format> &number_formats, xlnt::xml_node &number_formats_node)
 {
-    initialize_vectors();
-    
-    xml_document doc;
-    auto root_node = doc.add_child("styleSheet");
-    doc.add_namespace("", "http://schemas.openxmlformats.org/spreadsheetml/2006/main");
-    doc.add_namespace("mc", "http://schemas.openxmlformats.org/markup-compatibility/2006");
-    root_node.add_attribute("mc:Ignorable", "x14ac");
-    doc.add_namespace("x14ac", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac");
+    number_formats_node.add_attribute("count", std::to_string(number_formats.size()));
 
-    if (number_formats_.size() > 1 || !(number_formats_.front() == number_format::general()))
-    {
-        auto number_formats_node = root_node.add_child("numFmts");
-        write_number_formats(number_formats_node);
-    }
-
-    auto fonts_node = root_node.add_child("fonts");
-    write_fonts(fonts_node);
-
-    auto fills_node = root_node.add_child("fills");
-    write_fills(fills_node);
-    
-    auto borders_node = root_node.add_child("borders");
-    write_borders(borders_node);
-    
-    auto cell_style_xfs_node = root_node.add_child("cellStyleXfs");
-
-    auto cell_xfs_node = root_node.add_child("cellXfs");
-    write_formats(cell_xfs_node);
-    
-    auto cell_styles_node = root_node.add_child("cellStyles");
-    write_styles(cell_styles_node, cell_style_xfs_node);
-    
-    auto dxfs_node = root_node.add_child("dxfs");
-    write_dxfs(dxfs_node);
-
-    auto table_styles_node = root_node.add_child("tableStyles");
-    write_table_styles(table_styles_node);
-
-    if(!colors_.empty())
-    {
-        auto colors_node = root_node.add_child("colors");
-        write_colors(colors_node);
-    }
-    
-    auto ext_list_node = root_node.add_child("extLst");
-    write_ext_list(ext_list_node);
-
-    return doc;
-}
-
-bool style_serializer::write_number_formats(xml_node &number_formats_node) const
-{
-    number_formats_node.add_attribute("count", std::to_string(number_formats_.size()));
-
-    for (const auto &num_fmt : number_formats_)
+    for (const auto &num_fmt : number_formats)
     {
         auto num_fmt_node = number_formats_node.add_child("numFmt");
         num_fmt_node.add_attribute("numFmtId", std::to_string(num_fmt.get_id()));
@@ -1346,29 +1170,85 @@ bool style_serializer::write_number_formats(xml_node &number_formats_node) const
     return true;
 }
 
-const std::vector<border> &style_serializer::get_borders() const
+} // namespace
+
+namespace xlnt {
+
+style_serializer::style_serializer(detail::stylesheet &stylesheet) : stylesheet_(stylesheet)
 {
-    return borders_;
 }
 
-const std::vector<fill> &style_serializer::get_fills() const
+bool style_serializer::read_stylesheet(const xml_document &xml)
 {
-    return fills_;
+    auto stylesheet_node = xml.get_child("styleSheet");
+
+    read_borders(stylesheet_node.get_child("borders"), stylesheet_.borders);
+    read_fills(stylesheet_node.get_child("fills"), stylesheet_.fills);
+    read_fonts(stylesheet_node.get_child("fonts"), stylesheet_.fonts);
+    read_number_formats(stylesheet_node.get_child("numFmts"), stylesheet_.number_formats);
+    read_colors(stylesheet_node.get_child("colors"), stylesheet_.colors);
+    read_styles(stylesheet_node.get_child("cellStyles"), stylesheet_node.get_child("cellStyleXfs"), stylesheet_, stylesheet_.styles, stylesheet_.style_name_map);
+    read_formats(stylesheet_node.get_child("cellXfs"), stylesheet_, stylesheet_.formats, stylesheet_.format_styles);
+
+    return true;
 }
 
-const std::vector<font> &style_serializer::get_fonts() const
+bool style_serializer::write_stylesheet(xml_document &doc)
 {
-    return fonts_;
-}
+    auto root_node = doc.add_child("styleSheet");
+    doc.add_namespace("", "http://schemas.openxmlformats.org/spreadsheetml/2006/main");
+    doc.add_namespace("mc", "http://schemas.openxmlformats.org/markup-compatibility/2006");
+    root_node.add_attribute("mc:Ignorable", "x14ac");
+    doc.add_namespace("x14ac", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac");
 
-const std::vector<number_format> &style_serializer::get_number_formats() const
-{
-    return number_formats_;
-}
+    if (!stylesheet_.number_formats.empty())
+    {
+        auto number_formats_node = root_node.add_child("numFmts");
+        write_number_formats(stylesheet_.number_formats, number_formats_node);
+    }
 
-const std::vector<color> &style_serializer::get_colors() const
-{
-    return colors_;
+    if (!stylesheet_.fonts.empty())
+    {
+        auto fonts_node = root_node.add_child("fonts");
+        write_fonts(stylesheet_.fonts, fonts_node);
+    }
+
+    if (!stylesheet_.fills.empty())
+    {
+        auto fills_node = root_node.add_child("fills");
+        write_fills(stylesheet_.fills, fills_node);
+    }
+
+    if (!stylesheet_.borders.empty())
+    {
+        auto borders_node = root_node.add_child("borders");
+        write_borders(stylesheet_.borders, borders_node);
+    }
+    
+    auto cell_style_xfs_node = root_node.add_child("cellStyleXfs");
+    
+    auto cell_xfs_node = root_node.add_child("cellXfs");
+    write_formats(stylesheet_, cell_xfs_node);
+
+    auto cell_styles_node = root_node.add_child("cellStyles");
+    write_styles(stylesheet_, cell_styles_node, cell_style_xfs_node);
+    
+    auto dxfs_node = root_node.add_child("dxfs");
+    write_dxfs(dxfs_node);
+
+    auto table_styles_node = root_node.add_child("tableStyles");
+    write_table_styles(table_styles_node);
+
+    if(!stylesheet_.colors.empty())
+    {
+        auto colors_node = root_node.add_child("colors");
+        write_colors(stylesheet_.colors, colors_node);
+    }
+    
+    auto ext_list_node = root_node.add_child("extLst");
+    write_ext_list(ext_list_node);
+
+    return true;
 }
 
 } // namespace xlnt
diff --git a/source/serialization/tests/test_style_writer.hpp b/source/serialization/tests/test_style_writer.hpp
index 72b7519f..4ef8aa66 100644
--- a/source/serialization/tests/test_style_writer.hpp
+++ b/source/serialization/tests/test_style_writer.hpp
@@ -4,6 +4,8 @@
 #include <cxxtest/TestSuite.h>
 
 #include <xlnt/serialization/style_serializer.hpp>
+#include <detail/stylesheet.hpp>
+#include <detail/workbook_impl.hpp>
 
 class test_style_writer : public CxxTest::TestSuite
 {
@@ -12,15 +14,17 @@ public:
     {
         xlnt::workbook wb;
         wb.get_active_sheet().get_cell("A1").set_number_format(xlnt::number_format("YYYY"));
-        xlnt::style_serializer writer(wb);
+        xlnt::excel_serializer excel_serializer(wb);
+        xlnt::style_serializer style_serializer(excel_serializer.get_stylesheet());
         xlnt::xml_document observed;
-        auto num_fmts_node = observed.add_child("numFmts");
-        writer.write_number_formats(num_fmts_node);
+        style_serializer.write_stylesheet(observed);
+        xlnt::xml_document expected_doc;
         std::string expected =
         "    <numFmts count=\"1\">"
         "    <numFmt formatCode=\"YYYY\" numFmtId=\"164\"></numFmt>"
         "    </numFmts>";
-        auto diff = Helper::compare_xml(expected, observed);
+        expected_doc.from_string(expected);
+        auto diff = Helper::compare_xml(expected_doc.get_child("numFmts"), observed.get_child("styleSheet").get_child("numFmts"));
         TS_ASSERT(diff);
     }
     /*
diff --git a/source/serialization/worksheet_serializer.cpp b/source/serialization/worksheet_serializer.cpp
index 5f417d0d..3061c634 100644
--- a/source/serialization/worksheet_serializer.cpp
+++ b/source/serialization/worksheet_serializer.cpp
@@ -40,6 +40,7 @@
 #include <xlnt/worksheet/row_properties.hpp>
 
 #include <detail/constants.hpp>
+#include <detail/stylesheet.hpp>
 
 namespace {
 
@@ -56,7 +57,7 @@ worksheet_serializer::worksheet_serializer(worksheet sheet) : sheet_(sheet)
 {
 }
 
-bool worksheet_serializer::read_worksheet(const xml_document &xml)
+bool worksheet_serializer::read_worksheet(const xml_document &xml, detail::stylesheet &stylesheet)
 {
     auto &root_node = xml.get_child("worksheet");
 
@@ -198,7 +199,7 @@ bool worksheet_serializer::read_worksheet(const xml_document &xml)
 
                 if (has_format)
                 {
-                    cell.set_format(sheet_.get_workbook().get_format(format_id));
+                    cell.set_format(stylesheet.formats.at(format_id));
                 }
             }
         }
diff --git a/source/styles/common_style.cpp b/source/styles/common_style.cpp
index fde05a49..07e39ded 100644
--- a/source/styles/common_style.cpp
+++ b/source/styles/common_style.cpp
@@ -21,11 +21,11 @@
 //
 // @license: http://www.opensource.org/licenses/mit-license.php
 // @author: see AUTHORS file
-#include <xlnt/styles/formattable.hpp>
+#include <xlnt/styles/base_format.hpp>
 
 namespace xlnt {
 
-formattable::formattable()
+base_format::base_format()
     : apply_alignment_(false),
       apply_border_(false),
       apply_fill_(false),
@@ -35,7 +35,7 @@ formattable::formattable()
 {
 }
 
-formattable::formattable(const formattable &other)
+base_format::base_format(const base_format &other)
     : alignment_(other.alignment_),
       border_(other.border_),
       fill_(other.fill_),
@@ -51,7 +51,7 @@ formattable::formattable(const formattable &other)
 {
 }
 
-formattable &formattable::operator=(const xlnt::formattable &other)
+base_format &base_format::operator=(const xlnt::base_format &other)
 {
     alignment_ = other.alignment_;
     border_ = other.border_;
@@ -70,105 +70,105 @@ formattable &formattable::operator=(const xlnt::formattable &other)
     return *this;
 }
 
-alignment &formattable::get_alignment()
+alignment &base_format::get_alignment()
 {
     return alignment_;
 }
 
-const alignment &formattable::get_alignment() const
+const alignment &base_format::get_alignment() const
 {
     return alignment_;
 }
 
-void formattable::set_alignment(const xlnt::alignment &new_alignment)
+void base_format::set_alignment(const xlnt::alignment &new_alignment)
 {
     alignment_ = new_alignment;
     alignment_applied(true);
 }
 
-number_format &formattable::get_number_format()
+number_format &base_format::get_number_format()
 {
     return number_format_;
 }
 
-const number_format &formattable::get_number_format() const
+const number_format &base_format::get_number_format() const
 {
     return number_format_;
 }
 
-void formattable::set_number_format(const xlnt::number_format &new_number_format)
+void base_format::set_number_format(const xlnt::number_format &new_number_format)
 {
     number_format_ = new_number_format;
     number_format_applied(true);
 }
 
-border &formattable::get_border()
+border &base_format::get_border()
 {
     return border_;
 }
 
-const border &formattable::get_border() const
+const border &base_format::get_border() const
 {
     return border_;
 }
 
-void formattable::set_border(const xlnt::border &new_border)
+void base_format::set_border(const xlnt::border &new_border)
 {
     border_ = new_border;
     border_applied(true);
 }
 
-fill &formattable::get_fill()
+fill &base_format::get_fill()
 {
     return fill_;
 }
 
-const fill &formattable::get_fill() const
+const fill &base_format::get_fill() const
 {
     return fill_;
 }
 
-void formattable::set_fill(const xlnt::fill &new_fill)
+void base_format::set_fill(const xlnt::fill &new_fill)
 {
     fill_ = new_fill;
     fill_applied(true);
 }
 
-font &formattable::get_font()
+font &base_format::get_font()
 {
     return font_;
 }
 
-const font &formattable::get_font() const
+const font &base_format::get_font() const
 {
     return font_;
 }
 
-void formattable::set_font(const xlnt::font &new_font)
+void base_format::set_font(const xlnt::font &new_font)
 {
     font_ = new_font;
     font_applied(true);
 }
 
-protection &formattable::get_protection()
+protection &base_format::get_protection()
 {
     return protection_;
 }
 
-const protection &formattable::get_protection() const
+const protection &base_format::get_protection() const
 {
     return protection_;
 }
 
-void formattable::set_protection(const xlnt::protection &new_protection)
+void base_format::set_protection(const xlnt::protection &new_protection)
 {
     protection_ = new_protection;
     protection_applied(true);
 }
 
-std::string formattable::to_hash_string() const
+std::string base_format::to_hash_string() const
 {
-    std::string hash_string("formattable:");
+    std::string hash_string("base_format:");
     
     hash_string.append(std::to_string(alignment_applied()));
     hash_string.append(alignment_applied() ? std::to_string(alignment_.hash()) : ":");
@@ -191,62 +191,62 @@ std::string formattable::to_hash_string() const
     return hash_string;
 }
 
-void formattable::alignment_applied(bool applied)
+void base_format::alignment_applied(bool applied)
 {
     apply_alignment_ = applied;
 }
 
-void formattable::border_applied(bool applied)
+void base_format::border_applied(bool applied)
 {
     apply_border_ = applied;
 }
 
-void formattable::fill_applied(bool applied)
+void base_format::fill_applied(bool applied)
 {
     apply_fill_ = applied;
 }
 
-void formattable::font_applied(bool applied)
+void base_format::font_applied(bool applied)
 {
     apply_font_ = applied;
 }
 
-void formattable::number_format_applied(bool applied)
+void base_format::number_format_applied(bool applied)
 {
     apply_number_format_ = applied;
 }
 
-void formattable::protection_applied(bool applied)
+void base_format::protection_applied(bool applied)
 {
     apply_protection_ = applied;
 }
 
-bool formattable::alignment_applied() const
+bool base_format::alignment_applied() const
 {
     return apply_alignment_;
 }
 
-bool formattable::border_applied() const
+bool base_format::border_applied() const
 {
     return apply_border_;
 }
 
-bool formattable::fill_applied() const
+bool base_format::fill_applied() const
 {
     return apply_fill_;
 }
 
-bool formattable::font_applied() const
+bool base_format::font_applied() const
 {
     return apply_font_;
 }
 
-bool formattable::number_format_applied() const
+bool base_format::number_format_applied() const
 {
     return apply_number_format_;
 }
 
-bool formattable::protection_applied() const
+bool base_format::protection_applied() const
 {
     return apply_protection_;
 }
diff --git a/source/styles/fill.cpp b/source/styles/fill.cpp
index a526f2ba..ed168840 100644
--- a/source/styles/fill.cpp
+++ b/source/styles/fill.cpp
@@ -26,6 +26,18 @@
 
 namespace xlnt {
 
+fill::fill()
+    : type_(type::pattern),
+      pattern_type_(pattern_type::none),
+      gradient_type_(gradient_type::linear),
+      rotation_(0),
+      gradient_path_left_(0),
+      gradient_path_right_(0),
+      gradient_path_top_(0),
+      gradient_path_bottom_(0)
+{
+}
+
 fill::type fill::get_type() const
 {
     return type_;
diff --git a/source/styles/font.cpp b/source/styles/font.cpp
index db93bb08..d8c453dd 100644
--- a/source/styles/font.cpp
+++ b/source/styles/font.cpp
@@ -26,6 +26,24 @@
 
 namespace xlnt {
 
+
+font::font()
+    : name_("Calibri"),
+      size_(12),
+      bold_(false),
+      italic_(false),
+      superscript_(false),
+      subscript_(false),
+      underline_(underline_style::none),
+      strikethrough_(false),
+      color_(xlnt::color::type::theme, 1),
+      has_family_(true),
+      family_(2),
+      has_scheme_(true),
+      scheme_("minor")
+{
+}
+
 void font::set_bold(bool bold)
 {
     bold_ = bold;
diff --git a/source/styles/format.cpp b/source/styles/format.cpp
index 4912cc9d..b7ecf03f 100644
--- a/source/styles/format.cpp
+++ b/source/styles/format.cpp
@@ -31,60 +31,27 @@
 
 namespace xlnt {
 
-format::format()
-    : formattable(),
-      parent_(nullptr),
-      named_style_name_("Normal")
+format::format() : base_format()
 {
 }
 
-format::format(const format &other)
-    : formattable(other),
-      parent_(other.parent_),
-      named_style_name_(other.named_style_name_)
+format::format(const format &other) : base_format(other)
 {
 }
 
 format &format::operator=(const format &other)
 {
-    formattable::operator=(other);
-    
-    parent_ = other.parent_;
-    named_style_name_ = other.named_style_name_;
+    base_format::operator=(other);
 
     return *this;
 }
 
 std::string format::to_hash_string() const
 {
-    auto hash_string = formattable::to_hash_string();
+    auto hash_string = base_format::to_hash_string();
     hash_string.append(":format:");
-    
-    if (!named_style_name_.empty())
-    {
-        hash_string.append(named_style_name_);
-    }
-    else
-    {
-        hash_string.append(":");
-    }
 
     return hash_string;
 }
 
-void format::set_style(const std::string &style_name)
-{
-    named_style_name_ = style_name;
-}
-
-bool format::has_style() const
-{
-    return !named_style_name_.empty();
-}
-
-std::string format::get_style_name() const
-{
-    return named_style_name_;
-}
-
 } // namespace xlnt
diff --git a/source/styles/number_format.cpp b/source/styles/number_format.cpp
index a23492c4..0e3572f9 100644
--- a/source/styles/number_format.cpp
+++ b/source/styles/number_format.cpp
@@ -70,7 +70,7 @@ const std::unordered_map<std::size_t, std::string> &builtin_formats()
             { 42, "_(\"$\"* #,##0_);_(\"$\"* \\(#,##0\\);_(\"$\"* \"-\"_);_(@_)" },
             { 43, "_(* #,##0.00_);_(* \\(#,##0.00\\);_(* \"-\"??_);_(@_)" },
 
-            { 44, "_(\"$\"* #,##0.00_)_(\"$\"* \\(#,##0.00\\)_(\"$\"* \"-\"??_)_(@_)" },
+            { 44, "_-\"$\"* #,##0.00_-;\\-\"$\"* #,##0.00_-;_-\"$\"* \"-\"??_-;_-@_-" },
             { 45, "mm:ss" },
             { 46, "[h]:mm:ss" },
             { 47, "mmss.0" },
diff --git a/source/styles/style.cpp b/source/styles/style.cpp
index 75f717f3..cd037475 100644
--- a/source/styles/style.cpp
+++ b/source/styles/style.cpp
@@ -27,14 +27,14 @@
 namespace xlnt {
 
 style::style()
-    : formattable(),
+    : base_format(),
       hidden_(false),
       builtin_id_(0)
 {
 }
 
 style::style(const style &other)
-    : formattable(other),
+    : base_format(other),
       name_(other.name_),
       hidden_(other.hidden_),
       builtin_id_(other.builtin_id_)
@@ -43,7 +43,7 @@ style::style(const style &other)
 
 style &style::operator=(const style &other)
 {
-    formattable::operator=(other);
+    base_format::operator=(other);
     
     name_ = other.name_;
     hidden_ = other.hidden_;
@@ -84,7 +84,7 @@ void style::set_name(const std::string &name)
 
 std::string style::to_hash_string() const
 {
-    return formattable::to_hash_string() + name_;
+    return base_format::to_hash_string() + name_;
 }
 
 } // namespace xlnt
diff --git a/source/styles/tests/test_stylesheet.hpp b/source/styles/tests/test_stylesheet.hpp
index 653e926b..53e30c01 100644
--- a/source/styles/tests/test_stylesheet.hpp
+++ b/source/styles/tests/test_stylesheet.hpp
@@ -15,9 +15,12 @@ public:
     void test_ctor()
     {
         xlnt::workbook wb;
-        xlnt::style_serializer style_serializer(wb);
+        xlnt::excel_serializer excel_serializer(wb);
+        xlnt::style_serializer style_serializer(excel_serializer.get_stylesheet());
         xlnt::zip_file archive;
-        auto stylesheet_xml = style_serializer.write_stylesheet().to_string();
+        xlnt::xml_document stylesheet_doc;
+        style_serializer.write_stylesheet(stylesheet_doc);
+        auto stylesheet_xml = stylesheet_doc.to_string();
         
         const std::string expected =
         "<styleSheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:x14ac=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac\" mc:Ignorable=\"x14ac\">"
@@ -72,9 +75,10 @@ public:
         auto xml = PathHelper::read_file(PathHelper::GetDataDirectory("/reader/styles/simple-styles.xml"));
         doc.from_string(xml);
         xlnt::workbook wb;
-        xlnt::style_serializer s(wb);
+        xlnt::excel_serializer e(wb);
+        xlnt::style_serializer s(e.get_stylesheet());
         TS_ASSERT(s.read_stylesheet(doc));
-        TS_ASSERT_EQUALS(s.get_number_formats().size(), 1);
+        TS_ASSERT_EQUALS(e.get_stylesheet().number_formats.size(), 1);
     }
 
     void test_from_complex()
@@ -83,12 +87,13 @@ public:
         auto xml = PathHelper::read_file(PathHelper::GetDataDirectory("/reader/styles/complex-styles.xml"));
         doc.from_string(xml);
         xlnt::workbook wb;
-        xlnt::style_serializer s(wb);
+        xlnt::excel_serializer e(wb);
+        xlnt::style_serializer s(e.get_stylesheet());
         TS_ASSERT(s.read_stylesheet(doc));
-        TS_ASSERT_EQUALS(s.get_borders().size(), 7);
-        TS_ASSERT_EQUALS(s.get_fills().size(), 6);
-        TS_ASSERT_EQUALS(s.get_fonts().size(), 8);
-        TS_ASSERT_EQUALS(s.get_number_formats().size(), 1);
+        TS_ASSERT_EQUALS(e.get_stylesheet().borders.size(), 7);
+        TS_ASSERT_EQUALS(e.get_stylesheet().fills.size(), 6);
+        TS_ASSERT_EQUALS(e.get_stylesheet().fonts.size(), 8);
+        TS_ASSERT_EQUALS(e.get_stylesheet().number_formats.size(), 0);
     }
 
 /*
diff --git a/source/workbook/workbook.cpp b/source/workbook/workbook.cpp
index d0429714..fa860494 100644
--- a/source/workbook/workbook.cpp
+++ b/source/workbook/workbook.cpp
@@ -24,6 +24,7 @@
 #include <algorithm>
 #include <array>
 #include <fstream>
+#include <functional>
 #include <set>
 #include <sstream>
 
@@ -60,7 +61,10 @@ namespace xlnt {
 namespace detail {
 
 workbook_impl::workbook_impl()
-    : active_sheet_index_(0), guess_types_(false), data_only_(false), read_only_(false), next_custom_format_id_(164)
+    : active_sheet_index_(0),
+      guess_types_(false),
+      data_only_(false),
+      read_only_(false)
 {
 }
 
@@ -86,6 +90,7 @@ workbook::workbook() : d_(new detail::workbook_impl())
     
     add_format(format());
     create_style("Normal");
+    d_->stylesheet_.format_styles.front() = "Normal";
 }
 
 workbook::workbook(encoding e) : workbook()
@@ -555,11 +560,6 @@ workbook::~workbook()
 {
 }
 
-const std::vector<style> &workbook::get_styles() const
-{
-    return d_->styles_;
-}
-
 bool workbook::get_data_only() const
 {
     return d_->data_only_;
@@ -609,65 +609,63 @@ std::vector<named_range> workbook::get_named_ranges() const
     return named_ranges;
 }
 
-std::size_t workbook::add_format(const format &style)
+std::size_t workbook::add_format(const format &to_add)
 {
-    auto format_copy = style;
-    
-    //TODO this is ugly
-    if (!style.get_number_format().has_id())
-    {
-        bool match = false;
-        
-        for (std::size_t i = 0; i < d_->formats_.size(); i++)
-        {
-            const auto &current_number_format = d_->formats_.at(i).get_number_format();
-            
-            if (current_number_format.get_format_string() == format_copy.get_number_format().get_format_string())
-            {
-                format_copy.set_number_format(current_number_format);
-                match = true;
-                break;
-            }
-        }
-        
-        if (!match)
-        {
-            format_copy.get_number_format().set_id(d_->next_custom_format_id_++);
-        }
-    }
-    
-    // TODO hashmap?
-    for (std::size_t i = 0; i < d_->formats_.size(); i++)
-    {
-        if (d_->formats_[i] == format_copy)
-        {
-            return i;
-        }
-    }
-    
-    d_->formats_.push_back(format_copy);
-    
-    return d_->formats_.size() - 1;
+    return d_->stylesheet_.add_format(to_add);
+}
+
+std::size_t workbook::add_style(const style &to_add)
+{
+    return d_->stylesheet_.add_style(to_add);
+}
+
+bool workbook::has_style(const std::string &name) const
+{
+    return std::find_if(d_->stylesheet_.styles.begin(), d_->stylesheet_.styles.end(),
+        [&](const style &s) { return s.get_name() == name; }) != d_->stylesheet_.styles.end();
+}
+
+std::size_t workbook::get_style_id(const std::string &name) const
+{
+    return std::distance(d_->stylesheet_.styles.begin(),
+        std::find_if(d_->stylesheet_.styles.begin(), d_->stylesheet_.styles.end(),
+            [&](const style &s) { return s.get_name() == name; }));
 }
 
 void workbook::clear_styles()
 {
-    d_->styles_.clear();
+    d_->stylesheet_.styles.clear();
+    apply_to_cells([](cell c) { c.clear_style(); });
 }
 
 void workbook::clear_formats()
 {
-    d_->formats_.clear();
+    d_->stylesheet_.formats.clear();
+    apply_to_cells([](cell c) { c.clear_format(); });
+}
+
+void workbook::apply_to_cells(std::function<void(cell)> f)
+{
+    for (auto ws : *this)
+    {
+        for (auto r : ws.iter_cells(true))
+        {
+            for (auto c : r)
+            {
+                f.operator()(c);
+            }
+        }
+    }
 }
 
 format &workbook::get_format(std::size_t format_index)
 {
-    return d_->formats_.at(format_index);
+    return d_->stylesheet_.formats.at(format_index);
 }
 
 const format &workbook::get_format(std::size_t format_index) const
 {
-    return d_->formats_.at(format_index);
+    return d_->stylesheet_.formats.at(format_index);
 }
 
 manifest &workbook::get_manifest()
@@ -749,30 +747,30 @@ style &workbook::create_style(const std::string &name)
     style style;
     style.set_name(name);
     
-    d_->styles_.push_back(style);
+    d_->stylesheet_.styles.push_back(style);
     
-    return d_->styles_.back();
+    return d_->stylesheet_.styles.back();
 }
 
 std::vector<format> &workbook::get_formats()
 {
-    return d_->formats_;
+    return d_->stylesheet_.formats;
 }
 
 const std::vector<format> &workbook::get_formats() const
 {
-    return d_->formats_;
+    return d_->stylesheet_.formats;
 }
 
 style &workbook::get_style(const std::string &name)
 {
-    return *std::find_if(d_->styles_.begin(), d_->styles_.end(),
+    return *std::find_if(d_->stylesheet_.styles.begin(), d_->stylesheet_.styles.end(),
         [&name](const style &s) { return s.get_name() == name; });
 }
 
 const style &workbook::get_style(const std::string &name) const
 {
-    return *std::find_if(d_->styles_.begin(), d_->styles_.end(),
+    return *std::find_if(d_->stylesheet_.styles.begin(), d_->stylesheet_.styles.end(),
         [&name](const style &s) { return s.get_name() == name; });
 }
 
diff --git a/source/worksheet/worksheet.cpp b/source/worksheet/worksheet.cpp
index 41af6b20..965c2723 100644
--- a/source/worksheet/worksheet.cpp
+++ b/source/worksheet/worksheet.cpp
@@ -43,6 +43,7 @@
 
 #include <detail/cell_impl.hpp>
 #include <detail/constants.hpp>
+#include <detail/workbook_impl.hpp>
 #include <detail/worksheet_impl.hpp>
 
 namespace xlnt {
@@ -995,4 +996,9 @@ sheet_view worksheet::get_sheet_view() const
     return d_->view_;
 }
 
+std::size_t worksheet::next_custom_number_format_id()
+{
+    return get_workbook().d_->stylesheet_.next_custom_format_id++;
+}
+
 } // namespace xlnt