In the documentation for the boost property tree there is an example of its proper use, given here or in the package in libs/property_tree/examples/debug_settings.cpp.
What I want to know is about the struct debug_settings line. Why make this a struct instead of a class? It even has two member functions, load(...) and save(...). I assume that the boost authors have a good reason for this, and that it has something to do with... efficiency somehow, even if a struct and a class are "technically" identical?
From the copyright year listed, I can guess that this is likely C++98, C++03, or C++0x, so the reasoning for using a struct instead of a class is at least from a pre-C++11 viewpoint.
// ----------------------------------------------------------------------------
// Copyright (C) 2002-2006 Marcin Kalicinski
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see www.boost.org
// ----------------------------------------------------------------------------
//[debug_settings_includes
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/foreach.hpp>
#include <string>
#include <set>
#include <exception>
#include <iostream>
namespace pt = boost::property_tree;
//]
//[debug_settings_data
struct debug_settings
{
std::string m_file; // log filename
int m_level; // debug level
std::set<std::string> m_modules; // modules where logging is enabled
void load(const std::string &filename);
void save(const std::string &filename);
};
//]
//[debug_settings_load
void debug_settings::load(const std::string &filename)
{
// Create empty property tree object
pt::ptree tree;
// Parse the XML into the property tree.
pt::read_xml(filename, tree);
// Use the throwing version of get to find the debug filename.
// If the path cannot be resolved, an exception is thrown.
m_file = tree.get<std::string>("debug.filename");
// Use the default-value version of get to find the debug level.
// Note that the default value is used to deduce the target type.
m_level = tree.get("debug.level", 0);
// Use get_child to find the node containing the modules, and iterate over
// its children. If the path cannot be resolved, get_child throws.
// A C++11 for-range loop would also work.
BOOST_FOREACH(pt::ptree::value_type &v, tree.get_child("debug.modules")) {
// The data function is used to access the data stored in a node.
m_modules.insert(v.second.data());
}
}
//]
//[debug_settings_save
void debug_settings::save(const std::string &filename)
{
// Create an empty property tree object.
pt::ptree tree;
// Put the simple values into the tree. The integer is automatically
// converted to a string. Note that the "debug" node is automatically
// created if it doesn't exist.
tree.put("debug.filename", m_file);
tree.put("debug.level", m_level);
// Add all the modules. Unlike put, which overwrites existing nodes, add
// adds a new node at the lowest level, so the "modules" node will have
// multiple "module" children.
BOOST_FOREACH(const std::string &name, m_modules)
tree.add("debug.modules.module", name);
// Write property tree to XML file
pt::write_xml(filename, tree);
}
//]
int main()
{
try
{
debug_settings ds;
ds.load("debug_settings.xml");
ds.save("debug_settings_out.xml");
std::cout << "Success\n";
}
catch (std::exception &e)
{
std::cout << "Error: " << e.what() << "\n";
}
return 0;
}
I have looked at some previous posts on StackOverflow, but what I am really looking for is in this instance only. I have read through
- When should I use a struct instead of a class?,
- Should I use a Struct instead of a lightweight data class for my Linq2Sql data?,
- When to use struct over class in c++,
- When should you use a class vs a struct in C++?,
- Structs vs classes in C++, and
- Use of class and struct .
My thoughts:
To me this doesn't look like "Plain Old Data (POD)", because it has a member function and because it encapsulates class-based objects std::string and std::set. That string can change so I'm questioning "immutability". It has more than 1 data-type in it and it is likely larger than a 2 bytes. It has access loading and saving functionality which make it more than a simple structure. Boost is a C++ library, so it shouldn't expect that someone will be using it for C.
