boost serialization of nested struct does not work

Question

I'm trying to serialize a struct which contains two or more other types of sturct. But it seems that serialization does not work. Below is sampel code :

//SimpleData.hpp

#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp> 
#include <boost/serialization/optional.hpp> 
#include <boost/serialization/map.hpp> 
#include <boost/serialization/shared_ptr.hpp>

namespace A
{

Struct Name
{
    std::string firstname;
    std::string lastname;

      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
         ar & firstname;
         ar & lastname;
      } 
};

Struct Address
{
   std::string street;
   std::string city;

      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
         ar & street;
         ar & city;
      } 

}

Struct FullData 
{

  public :
      FullData();
      FullData(const parameter_strings & parms);

      virtual ~FullData();

      boost::optional<Name> nameinfo;       // instance of struct Name
      boost::optional<Address> addressinfo;    // instance of struct Address

      std::string country;
      std::int pincode;

  private :
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
         ar & nameinfo;       // are these enough to take of serialization of Name and 
         ar & addressinfo;   // Address
         ar & country;;
         ar & pincode;
      } 
};

}

//SimpleData.cpp

#include "SimpleData.hpp"

FullData::FullData()
{

}

FullData::~FullData()
{

}

FullData::~FullData(const parameter_strings & parms): Detail(parms)
{

 // impelmentation
}


BOOST_CLASS_EXPORT_IMPLEMENT(FullData);
BOOST_CLASS_IMPLEMENTATION(FullData),boost::serialization::object_serializable);
BOOST_CLASS_TRACKING(FullData),boost::serialization::track_never);

I'm not sure if above code would serialize properly or not. Whats wrong with above code. Do i need to add below code also for serialization of Name and Address struct in SimpleData.cpp file

BOOST_CLASS_EXPORT_IMPLEMENT(Name);
BOOST_CLASS_IMPLEMENTATION(name,boost::serialization::object_serializable);
BOOST_CLASS_TRACKING(Name,boost::serialization::track_never);


BOOST_CLASS_EXPORT_IMPLEMENT(Address);
BOOST_CLASS_IMPLEMENTATION(Address,boost::serialization::object_serializable);
BOOST_CLASS_TRACKING(Address,boost::serialization::track_never);

Answer 1

I don't know what the question was. I /do/ know that the code was littered with errors.

I fixed those, and behold: workiness:

int main()
{
    A::FullData data({ { "key1", "value1" }, { "key2" , "value2" } });
    data.nameinfo    = A::Name    { "firstname", "lastname" };
    data.addressinfo = A::Address { "street", "city" };
    data.pincode     = 99977;
    data.country     = "Gibraltar";

    boost::archive::text_oarchive oa(std::cout);
    oa << data;
}

Prints

22 serialization::archive 10 0 0 1 0 0 0 9 firstname 8 lastname 0 0 1 0 0 0 6 street 4 city 9 Gibraltar 99977 0 0 2 0 0 0 4 key1 6 value1 4 key2 6 value2

See it Live On Coliru

SimpleData.hpp

#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp> 
#include <boost/serialization/optional.hpp> 
#include <boost/serialization/map.hpp> 
#include <boost/serialization/shared_ptr.hpp>

namespace A
{
    typedef std::map<std::string, std::string> parameter_strings;
    struct Name
    {
        std::string firstname;
        std::string lastname;

        template<class Archive>
            void serialize(Archive &ar, const unsigned int version)
            {
                ar & firstname;
                ar & lastname;
            } 
    };

    struct Address
    {
        std::string street;
        std::string city;

        template<class Archive>
            void serialize(Archive &ar, const unsigned int version)
            {
                ar & street;
                ar & city;
            } 

    };

    struct FullData 
    {
        FullData();
        FullData(const parameter_strings & parms);

        virtual ~FullData();

        boost::optional<Name> nameinfo;       // instance of struct Name
        boost::optional<Address> addressinfo; // instance of struct Address
        parameter_strings detail;

        std::string country;
        int pincode;

        private :
        friend class boost::serialization::access;
        template<class Archive>
            void serialize(Archive &ar, const unsigned int version)
            {
                ar & nameinfo;       // are these enough to take of serialization of Name and 
                ar & addressinfo;   // Address
                ar & country;
                ar & pincode;
                ar & detail;
            } 
    };

}

SimpleData.cpp

#include "SimpleData.hpp"
#include <boost/serialization/export.hpp>

namespace A
{
    FullData::FullData()
    {

    }

    FullData::~FullData()
    {

    }

    FullData::FullData(const parameter_strings & parms): detail(parms)
    {

        // impelmentation
    }

}

#include <boost/archive/text_oarchive.hpp>

BOOST_CLASS_EXPORT_IMPLEMENT(A::FullData)
BOOST_CLASS_IMPLEMENTATION(A::FullData    , boost::serialization::object_serializable)
BOOST_CLASS_TRACKING(A::FullData          , boost::serialization::track_never)

int main()
{
    A::FullData data({ { "key1", "value1" }, { "key2" , "value2" } });
    data.nameinfo    = A::Name    { "firstname", "lastname" };
    data.addressinfo = A::Address { "street", "city" };
    data.pincode     = 99977;
    data.country     = "Gibraltar";

    boost::archive::text_oarchive oa(std::cout);
    oa << data;
}