Hiya,

I've heard that MPI was accepted and reviewed, but I can't find it in my
regular Boost distribution (ubuntu) nor in the web site.

If this is the specification, I'm SO looking forward to use it.

http://www.osl.iu.edu/~dgregor/boost.mpi/doc/

Do you have any ideas when / if this is going to be finally approved and
distributed with Boost?

cheers,
--renato

                        John Phillips

Scenario:

I have a class MyClass which have several entries of InternalClass objects (which is the one
I want a new version of):

class MyClass
{
    ...
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
       ar & BOOST_SERIALIZATION("MyInternals", m_vector_of_internal_class_objects);
    }

    std::vector<InternalClass> m_vector_of_internal_class_objects;

    class InternalClass
    {
       template<class Archive>
       void save(Archive & ar, const unsigned int version) const
       {
          ar & BOOST_SERIALIZATION("data", m_data);
       }

       template<class Archive>
       void load(Archive & ar, const unsigned int version)
       {
          if (version == 0)
          {
             old_data_t tmp;
             ar & BOOST_SERIALIZATION("data", tmp);
             m_data = convertToNewData(tmp);
          }
          else
          {
             BOOST_CHECK(version == 1);
             ar & BOOST_SERIALIZATION("data", m_data);
          }
       }
       BOOST_SERIALIZATION_SPLIT_MEMBER()

       new_data_t m_data;
    }

BOOST_CLASS_VERSION(MyClass::InternalClass, boost::serialization::object_class_info)
BOOST_CLASS_VERSION(MyClass::InternalClass, 1)

But when saving to the XML archive file, I still get version="0" for the InternalClass objects (?)

/R

Robert Ramey

        I have to build boost-library on a sparc64 server (32 bits userland).
This, I have downloaded boost_1_34_1.tar.bz2 and followed build
instructions I have found. I only obtain an error that I don't understand :

Root fermat:[/opt/src/boost_1_34_1] > ./configure --prefix=/opt
Building Boost.Jam with toolset gcc... tools/jam/src/bin.linuxsparc/bjam
Detecting Python version... 2.4
Detecting Python root... /usr
Unicode/ICU support for Boost.Regex?... not found.
Backing up existing Boost.Build configuration in user-config.jam.4
Generating Boost.Build configuration in user-config.jam...
Generating Makefile...
Root fermat:[/opt/src/boost_1_34_1] > ls
boost                  index.htm        people            user-config.jam
boost-build.jam        Jamfile.v2       project-root.jam  user-config.jam.1
boost.css              Jamrules         README            user-config.jam.2
boost.png              libs             regression        user-config.jam.3
configure              LICENSE_1_0.txt  rst.css           user-config.jam.4
doc                    Makefile         status            wiki
google_logo_40wht.png  more             tools
Root fermat:[/opt/src/boost_1_34_1] > make
./tools/jam/src/bin.linuxsparc/bjam  --user-config=user-config.jam
Unable to load Boost.Build: could not find "boost-build.jam"
---------------------------------------------------------------
Attempted search from /opt/src/boost_1_34_1 up to the root
and in these directories from BOOST_BUILD_PATH and BOOST_ROOT:
/usr/share/boost-build.
Please consult the documentation at 'http://www.boost.org'.
Not all Boost libraries built properly.
Root fermat:[/opt/src/boost_1_34_1] >

        I don't understand why bjam does not find boost-build.jam. This file is
in boost top directory. I have tried to set BOOST_BUILD_PATH and
BOOST_ROOT without any other success. What is my mistake ?

        Regards,

I ran into an issue I cannot explain, when using bind with the string
algorithms.
The following code fragment works as expected with MSVC 8.0:

#include <boost/algorithm/string/predicate.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <vector>
#include <string>

using namespace std;
using namespace boost;
using namespace boost::algorithm;

int main() {
    typedef vector<string> string_container;
    string_container numbers;
    numbers.push_back("one");
    numbers.push_back("two");
    numbers.push_back("three");

    string_container::const_iterator s = find_if(numbers.begin(),
numbers.end(),
        bind(&contains<string, string>, _1, "w"));

    if (s != numbers.end()) {
        cout << "Found: " << *s << endl;
    }

    return 0;

Does anyone has an idea how to let bind know the "type" of the predicate
"contains"?

Regards

Jean-Pierre Bergamin

    string_container::const_iterator s = find_if(numbers.begin(),
numbers.end(),
        bind((contains_type)&contains<string, string>, _1, "w"));

Or better, use a function object:

struct contains {
    typedef bool result_type;
    bool operator()(const string& arg1, const string& arg2) {
        return(boost::algorithm::contains(arg1, arg2));
    }