December 2007 - Boost-users - lists.preview.boost.org

Copying types from a mpl vector to a fusion vector
by Germán Diago 02 Dec '07

02 Dec '07

Hello. I'm trying to build a library and I'm doing heavy use of boost mpl and fusion libraries. I'd like to know a way to fill a boost::fusion::vector<> with the types contained in a boost::mpl::vector. Anyone knows how to do this? The code I have so far: template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10> struct Func { //This is the initial sequence typedef typename boost::mpl::vector<T1, T2, T3, T4, T5, T6, T7,… [View More]

2 2

[regex] problem with regular expression
by John Kiopela 02 Dec '07

02 Dec '07

Hi all, I am having some troubles with making a regular expression to parse a file of financial data. First, the file looks like this (simplified): BEGIN FINANCIAL INFORMATION 0 4 John (the name is mentioned somewhere between the two tags) 6 3 8 END FINANCIAL INFORMATION BEGIN FINANCIAL INFORMATION 0 David 6 8 END FINANCIAL INFORMATION BEGIN FINANCIAL INFORMATION 2 4 7 4 0 3 John 6 8 END FINANCIAL INFORMATION I want to create a regular … [View More]

2 1

boost-users [boost lambda, boost foreach]
by chun ping wang 02 Dec '07

02 Dec '07

Hi, lets say i have two arbitary container of any stl type. template < class T, template <typename ELEM, typename = std::allocator<ELEM> > class CONT > typename boost::enable_if<boost::is_floating_point<T>, T>::type getManhattanDistance(const CONT<T>& ObjectX, const CONT<T>& ObjectY) I want to be able to iterate through both containers to get the euclidean distance.. i.e. sqrt of sum of each item in ObjectX - ObjectY square. Psuedocode … [View More]

1 0

Runtime memory corruption occurs when serializing tree-structure as binary-archive.
by Youhei Murakami 02 Dec '07

02 Dec '07

Hello everyone. I tried to compile a code that has written below and I had met runtime error. That error is the memory corruption. A memory corruption occurs when just before exit main function and causes are in binary-serialization, but I don't understand this fenomenon. If someone who knows the reason of this matter, please tell me. [environment] Windows XP 64bit Visual Studio 2005 sp1 boost-1_34_1 #define _SCL_SECURE_NO_WARNINGS #pragma warning(push) #pragma warning(disable: 4267) #pragma … [View More]warning(disable: 4103) #include <stdio.h> #include <tchar.h> #define CRTDBG_MAP_ALLOC #include <stdlib.h> #include <crtdbg.h> #include <iostream> #include <fstream> #include <cstdlib> #include <vector> #include <boost/shared_ptr.hpp> #include <boost/weak_ptr.hpp> #include <boost/enable_shared_from_this.hpp> #include <boost/serialization/serialization.hpp> #include <boost/serialization/string.hpp> #include <boost/serialization/vector.hpp> #include <boost/serialization/shared_ptr.hpp> #include <boost/serialization/weak_ptr.hpp> #include <boost/serialization/version.hpp> #include <boost/serialization/base_object.hpp> #include <boost/serialization/tracking.hpp> #include <boost/serialization/is_abstract.hpp> #include <boost/serialization/nvp.hpp> #include <boost/serialization/binary_object.hpp> #include <boost/serialization/split_member.hpp> #define BOOST_LIB_NAME boost_serialization #include <boost/config/auto_link.hpp> #include <boost/archive/binary_iarchive.hpp> #include <boost/archive/binary_oarchive.hpp> #include <boost/serialization/export.hpp> #pragma warning(pop) using namespace std; using namespace boost; using namespace boost::serialization; using namespace boost::archive; namespace test { class nodebase : public enable_shared_from_this<nodebase> { // occurs memory corruption when serializing public: typedef shared_ptr<nodebase> NodePointer; typedef weak_ptr<nodebase> NodeWeakPointer; typedef vector<NodePointer> Children; typedef Children::iterator ChildIterator; typedef vector<NodeWeakPointer> Parents; typedef Parents::iterator ParentIterator; public: nodebase(); nodebase( const string &n ); nodebase( const string &n, const Children &c ); nodebase( const string &n, const Children &c, const Parents &p ); virtual ~nodebase(); private: struct Impl { Impl(); Impl( const string &n ); Impl( const string &n, const Children &v ); Impl( const string &n, const Children &v, const Parents &p ); public: string name; Children children; Parents parents; private: friend class serialization::access; template <class Archive> void serialize( Archive &ar, const unsigned int version ); }; shared_ptr<Impl> pimpl; private: // serialization friend class serialization::access; template <class Archive> void serialize( Archive &ar, const unsigned int version ); public: string getname( void ){ return pimpl->name; } void SetParent( const NodePointer &parent ); void SetParents( const Parents &parents ); NodePointer GetParent( const string &name ); Parents GetParents( void ); Children GetChildren( void ); void AddChild( const NodePointer &child ); void RemoveChild( const NodePointer &child ); void Traverse( void ); private: void Traverse( const NodePointer &root ); }; nodebase::Impl::Impl() { } nodebase::Impl::Impl( const string &n ) : name(n) { } nodebase::Impl::Impl( const string &n, const Children &c ) : name(n), children(c) { } nodebase::Impl::Impl( const string &n, const Children &c, const Parents &p ) : name(n), children(c), parents(p) { } template <class Archive> void nodebase::Impl::serialize( Archive &ar, const unsigned int version ) { ar & make_nvp( "name", make_binary_object( &name, sizeof(name) ) ); ar & make_nvp( "children", make_binary_object( &children, sizeof(children) ) ); ar & make_nvp( "parents", make_binary_object( &parents, sizeof(parents) ) ); } nodebase::nodebase() { } nodebase::nodebase( const string &n ) : pimpl( new Impl( n ) ) { } nodebase::nodebase( const string &n, const Children &c ) : pimpl( new Impl( n, c ) ) { } nodebase::nodebase( const string &n, const Children &c, const Parents &p ) : pimpl( new Impl( n, c, p ) ) { } nodebase::~nodebase() { } template <class Archive> void nodebase::serialize( Archive &ar, const unsigned int version ) { ar & make_nvp( "pimpl", make_binary_object( &pimpl, sizeof(pimpl) ) ); } template void nodebase::serialize<archive::binary_oarchive>( archive::binary_oarchive &ar, const unsigned int version ); template void nodebase::serialize<archive::binary_iarchive>( archive::binary_iarchive &ar, const unsigned int version ); void nodebase::SetParent( const nodebase::NodePointer &p ) { assert( pimpl->parents.size()+1 < 2 ); pimpl->parents.push_back( p ); } nodebase::NodePointer nodebase::GetParent( const string &name ) { for( ParentIterator i = pimpl->parents.begin(); i != pimpl->parents.end(); i++ ){ NodePointer tmp((*i)); if( tmp->getname() == name ) { return tmp; } } return NodePointer(); } nodebase::Parents nodebase::GetParents( void ) { return pimpl->parents; } nodebase::Children nodebase::GetChildren( void ) { return pimpl->children; } void nodebase::AddChild( const nodebase::NodePointer &child ) { child->SetParent( shared_from_this() ); //!!!!ERROR!!!! incur a memory leak this->pimpl->children.push_back( child ); } void nodebase::RemoveChild( const NodePointer &child ) { for( ChildIterator i = pimpl->children.begin(); i != pimpl->children.end(); i++ ){ if( (*i).get() == child.get() ){ pimpl->children.erase( i ); break; } } } void nodebase::Traverse( void ) { Children children = this->GetChildren(); for( ChildIterator i = children.begin(); i != children.end(); i++ ){ Traverse( *i ); } } void nodebase::Traverse( const NodePointer &node ) { if( !node ){ return; } Children children = node->GetChildren(); for( ChildIterator i = children.begin(); i != children.end(); i++ ) { Traverse( *i ); } } class simple_class { // not occur memory corruption when serializing friend class access; string name; template <class Archive> void serialize( Archive &ar, unsigned int ) { ar & name; } }; }; BOOST_CLASS_TRACKING(test::nodebase, boost::serialization::track_always); int _tmain(int argc, _TCHAR* argv[]) { using namespace test; { shared_ptr<nodebase> root( new nodebase(string("root")) ); shared_ptr<nodebase> c1( new nodebase(string("c1")) ); shared_ptr<nodebase> c2( new nodebase(string("c2")) ); shared_ptr<nodebase> c3( new nodebase(string("c3")) ); shared_ptr<nodebase> c4( new nodebase(string("c4")) ); shared_ptr<nodebase> c5( new nodebase(string("c5")) ); c3->AddChild( c5 ); c1->AddChild( c3 ); c2->AddChild( c4 ); root->AddChild( c1 ); root->AddChild( c2 ); root->Traverse(); { // output ofstream ofile( "serialized", ios::binary ); try { boost::archive::binary_oarchive oa( ofile ); oa << BOOST_SERIALIZATION_NVP(root); } catch( boost::archive::archive_exception &e ) { cout << "At the output : " << e.what() << endl; ofile.close(); getchar(); exit(1); } ofile.close(); } shared_ptr<nodebase> in; { // input ifstream ifile( "serialized", ios::binary ); try { boost::archive::binary_iarchive ia( ifile ); ia >> BOOST_SERIALIZATION_NVP(in); in->Traverse(); } catch( boost::archive::archive_exception &e ) { cout << "At the input : " << e.what() << endl; ifile.close(); getchar(); exit(e.code); } ifile.close(); } } getchar(); return 0; } [View Less]

1 0

Sequence modifying routines??
by John Femiani 01 Dec '07

01 Dec '07

Is there a reason that fusion seems devoid of sequence modifying routines except for the built-in assignment operators? For instance, if I wanted to operate on boost::array, I would seem to have no way to write the results back into an array through fusion (unless I miss something). I am looking for something like copy(input_sequence, output_sequence) -- John Femiani

1 0

BGL : maximum weighted matching
by Alessio Dore 01 Dec '07

01 Dec '07

Dear all, I am implementing an algorithm for which I would need to compute the maximum weighted matching of a bipartite graphs. I have seen that LEDA libraries has this sort of functions but their license is restrictive. BGL allows maximum cardinality matching but, if I understood well, it works for non-weighted graphs. In a previous message on this list it was mentioned that this functionality could have been added but I didn't find it. Is it available? Does anyone of you know if there are … [View More]

2 1

[statechart] context sensitive history
by Chris Paulse 01 Dec '07

01 Dec '07

I have the following requirement: States A and B, where B has two substates B1 and B2. When transition occurs from B to A, and then from A back to B, under some conditions it is desired for B1 to be the initial substate, while in others we would like the substate to be chosen based on B's shallow history. Is there a concise way to obtain this behavior from the statecharts library? Thanks, Chris

2 1