- Boost - lists.boost.org

[contract] Template types
by Lorenzo Caminiti 29 Jul '16

29 Jul '16

Hello all, I would like to discuss the extra type requirements that contracts can impose of generic types and how Boost.Contract handles that. I think I mentioned some of this already in different emails to this list, but I wanted to summarize this topic in one email. For example, note that the following code will not compile when the old value template parameter T is not copyable: template<typename T> void swap(T& a, T& b) [[ensures: a == old(b)]] ... In Boost.Contract (approach 1): template<typename T> void swap(T& a, T& b) { boost::contract::old_ptr<T> old_b = BOOST_CONTRACT_OLDOF(b); boost::contract::guard c = boost::contract::function() .postcondition([&] { BOOST_CONTRACT_ASSERT(a == *old_b); }) ; ... } In some cases, that might be what the contract writers want: the generic old value type T is not copyable so postconditions cannot be checked and the program should not compile. However, in some other cases the contract writes might not want to add the extra copyable requirement on T and check the related postconditions only when callers specify a template parameter T that happens to be copyable. That can be done allowing some sort of static-if in contracts: template<typename T> void swap(T& a, T& b) [[ensures: static if(is_copyable<T>::value) a == old(b)]] ... In Boost.Contract (approach 2): template<typename T> void swap(T& a, T& b) { boost::contract::old_ptr_if_copyable<T> old_b = BOOST_CONTRACT_OLDOF(b); boost::contract::guard c = boost::contract::function() .postcondition([&] { if(old_b) BOOST_CONTRACT_ASSERT(a == *old_b); }) ; ... } Both approach 1 and 2 above are valid and should be supported by the framework. The decision between which approach to use for a specific contract should be left up to the programmers. Like old values can introduce the extra copyable type requirement, any contract assertion can in general introduce an number of extra requirements on generic types, namely the type requirements necessary to support the operations used to program the contract assertions. For example, the following code will not compile if T is not equality comparable (which is not a type requirement vector normally imposes on T): template<typename T> class vector { void push_back(T const& value) [[ensures: back() == value]] ... }; In Boost.Contract (approach 1): template<typename T> class vector { void push_back(T const& value) { boost::contract::guard c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(back() == value); }) ; ... } }; Again, that might be what contract writes want in some case but in other cases they might want to just skip the assertion when T does not meet all the type requirements needed by the operations used in the assertion: template<typename T> class vector { void push_back(T const& value) [[ensures: static if(has_equal_to<T>::value) back() == value]] ... }; In Boost.Contract (approach 2): template<typename T> class vector { void push_back(T const& value) { boost::contract::guard c = boost::contract::public_function(this) .postcondition([&] { BOOST_CONTRACT_ASSERT( boost::contract::check_if<has_equal_to<T>::value >( boost::bind(equal_to<T>, cref(back()), cref(value)) ) ); }) ; ... } }; --Lorenzo

1 0

Gmane going away
by Tom Kent 29 Jul '16

29 Jul '16

So it looks like Gmane is under attack and the guy who runs it is thinking about just turning it off (that would be sad). https://lars.ingebrigtsen.no/2016/07/28/the-end-of-gmane/ Anyway, I know a lot of boost users use is as the gnu mailman archive pages are really hard to use. I would like to propose that we (specifically the list owner(s)) mirror the boost mailing lists to the mail-archive.com site. It has good search features and decent thread browse-ability. Thoughts? Tom

1 0

Boost Social Event at CppCon 2016
by Jon Kalb 28 Jul '16

28 Jul '16

Boost Developers, Because a lot of Boosters are going to be attending CppCon, we¹d like to arrange a social event for Boosters/C++Now attendees. http://cppcon.org/ If you are planning to attend CppCon or even If you are just going to be in or around Bellevue, Washington between September 17th and 23rd and you¹d like to join us for dinner, please let us know so we can get a count. Please send mail to: social(a)boost.org Once we settle on a date, etc, we¹ll let everyone who responded know when and where, so please let us know, even if you are a ³maybe.² If you are attending, please make your hotel reservations soon. We are likely to sell out of our room block. http://cppcon.org/lodging/ I hope to see you at CppCon. Jon

2 1

Approximate matching to Boost.Algorithm
by Зайцев Александр 27 Jul '16

27 Jul '16

Hello. I want to discuss about some proposals. I am working on Levenshtein distance and Damerau-Levenshtein distance algortihms. I hope, that these implementations will be pulled to the Boost String library. But i think that we can add to the Boost String Library some more algorithms for fuzzy searhing. You can find this list here: https://fuzzystring.codeplex.com/ List: 1)Hamming Distance 2)Jaccard Distance 3)Jaro Distance 4)Jaro-Winkler Distance 5)Levenshtein Distance 6)Longest Common Subsequence 7)Longest Common Substring 8)Overlap Coefficient 9)Ratcliff-Obershelp Similarity 10)Sorensen-Dice Distance 11)Tanimoto Coefficient Maybe something else... What do you think about this idea? If you think that it can be implemented to the Boost String Algo, i will start work on this list immediately. Best regards, Zaitsev Alexander.

2 1

I am working on Aho-Corasik
by Зайцев Александр 27 Jul '16

27 Jul '16

Hello. FYI: Now i am working on Aho-Corasik algorithm. Best regards, Alexander Zaitsev.

1 0

Fast nth-elemnt on the segment
by Зайцев Александр 26 Jul '16

26 Jul '16

Hello. What do you think about algorithm of fast searching nth-elemnt on the segment with O(logN), where N is count of elements. I would implement it to Boost.Algorithm. Best regards, Alexander Zaitsev

1 0

[type_erasure] Conflict with private member called data
by Nigel Pattinson 22 Jul '16

22 Jul '16

Hi I'm running into a problem with the type erasure library when trying to declare a member called 'data', e.g. BOOST_TYPE_ERASURE_MEMBER((has_data), data) using SomeClass = any< vector< copy_constructible<>, typeid_<>, relaxed, has_data<void*()> > >; This conflicts with the private member variable called 'data' in the any class. SomeClass does compile, but attempting to call the data() does not compile due to the conflict, with the error message being 'cannot access private member ... ' . I'm not sure if this is a limitation in the library or a compiler bug - I'm using Visual Studio 2015 Update 1. Using boost 1.57.0 at present, I could use a more recent version if that would help. Does anyone know of a possible workaround ? Thanks Nigel Pattinson

2 2

Update for the Cxx dual library
by Edward Diener 22 Jul '16

22 Jul '16

The Cxx dual library, or CXXD for short, is a C++ macro header-only library which chooses between using a Boost library or its C++ standard equivalent library for a number of different C++ implementations, while using the same code to program either choice. An 'implementation', called a 'dual library', is a Boost library which has a C++ standard library equivalent whose public interfaces are nearly the same in both cases. I have updated the Cxx dual library, for those who prefer to minimize their use of macros in source code, by providing an alternate method to the use of macros for including the appropriate header files and specifying the appropriate namespace for a dual library. In this alternate method including the appropriate header files is done by including an implementation header file, and specifying the appropriate namespace is done by using a C++ namespace alias. The alternate method, called the alias mode, is fully documented. You can get the latest version of the Cxx dual library at https://github.com/eldiener/cxx_dual. Instructions for using the library are in the README.md file. PDF documentation is available in cxx_dual.pdf, HTML doc is availavble online at http://eldiener.github.io/cxx_dual and you can generate local HTML documentation using the doc jam file. Questions, comments, bug reports are always welcome.

1 0

does boost support multimedia framework
by qw 22 Jul '16

22 Jul '16

Hi, Does boost support multimedia framework, just like gstreamer? Thanks! Regards Andrew

2 1

[contract] Class invariants (also for static and volatile/const-volatile public functions)
by Lorenzo Caminiti 21 Jul '16

21 Jul '16

Hello all, I would like to discuss class invariants, but also for static and volatile/const-volatile public member functions, and specifically with respect to how Boost.Contract handles them. Class invariants are important... almost as important as preconditions. For example for a vector container, class invariants specify among other things the equivalence relationship `(size() == 0) == empty()` that could be found useful by static analyzers and optimizes (also discussed in N4160): template<typename T> class vector { [[invariant: (size() == 0) == empty()]] [[invariant: size() <= capacity()]] public: void push_back(T const& value) ... { ... } }; The above contract cannot be programmed using preconditions and postconditions unless: it is repeated (together with all other invariant assertions) in pre- and postconditions of each public member functions, it is asserted with try-catches also when those functions throw, it is repeated in constructor postconditions, in destructor preconditions, and with try-catches also when destructors throw... Even if invariants are programmed in some `bool invariant() const` function to avoid repeating all invariant assertions in each pre- and postcondition, the code will be cluttered by boiler-plate code (try-catch to assert invariants on throw, etc.) and an invariant failure will just report that the invariant() function returned false, but it will not report which specific invariant condition actually failed (plus static analyzers and optimizes will not be able to parse the conditions from the invariant function): template<typename T> class vector { bool invariant() const { // But cannot distinguish which of the two assertions failed... // and cannot be used by static analyzers and optimizers. return (size() == 0) == empty() && size() <= capacity(); } public: void push_back(T const& value) ... [[requires: invariant()]] [[ensures: invariant()]] { try { ... } catch(...) { [[assert: invariant()]]; throw } } }; Class invariants cannot be effectively emulated using pre- and postconditions... they should be added to a contract framework as their own feature. In Boost.Contract: template<typename T> class vector { void invariant() const { BOOST_CONTRACT_ASSERT((size() == 0) == empty()); BOOST_CONTRACT_ASSERT(size() <= capacity()); } public: void push_back(T const& value) { boost::contract::guard c = boost::contract::public_function(*this) ... ; ... } }; Note that the above invariant function `void invariant() const` cannot be declared static or const-volatile because it will need to call queries like size(), empty(), capacity(), etc. that are const and not static or const-volatile. Thus the above invariant function, being const, cannot be called at entry and exit of static and volatile/const-volatile public functions. A contract framework for C++ should support also static and const-volatile class invariants to properly handle static and volatile/const-volatile public functions (even if static and const-volatile class invariants are not mentioned in any C++ contract proposal): * Static public functions check static class invariants at entry, at exit, and if body throws. * Volatile and const-volatile public functions check static and const-volatile class invariants (in that order) at entry, at exit, and if body throws. * Non cv-qualified and const public functions check static, const-volatile, and const class invariants (in that order) at entry, at exit, and if body throws. * Constructors check static class invariants at entry, at exit, and if body throws (because those do not require the object to be constructed). Then constructors check const-volatile and const class invariants (in that order) at exit (if body does not throw, because those require the object to be constructed). * Destructors check static class invariants at entry, at exit, and if body throws (because those do not require a constructed object). Then destructors check const-volatile and const class invariants (in that order) at entry and if body throws (because those require a constructed object). In Boost.Contract: struct a { static void static_invariant() { BOOST_CONTRACT_ASSERT(...); } void invariant() const volatile { BOOST_CONTRACT_ASSERT(...); } void invariant() const { BOOST_CONTRACT_ASSERT(...); } // Following check all static_invariant(), invariant() const volatile, and invariant() const (in that order). a() { boost::contract::guard c= boost::contract::constructor(this); } virtual ~a() { boost::contract::guard c = boost::contract::destructor(this); } void m() /* no cv qualifiers */ { boost::contract::guard c = boost::contract::public_function(*this); } void c() const { boost::contract::guard c = boost::contract::public_function(*this); } // Following check both static_invariant() and invariant() const volatile (in that order). void v() volatile { boost::contract::guard c = boost::contract::public_function(*this); } void cv() const volatile { boost::contract::guard c = boost::contract::public_function(*this); } // Following check only static_invariant(). static void s() { boost::contract::guard c = boost::contract::public_function<a>(); } }; Maybe volatile member functions are rarely used in C++ so const-volatile class invariants will also be used rarely if at all... Nevertheless, if const-volatile class invariants are not supported, it will not be possible to specify invariants for classes with volatile public functions so const-volatile class invariants should be supported for completeness. Static class invariant could instead be useful when programming contracts for the static part of the object state. In particular, Boost.Contract also supports postconditions for destructors (those should be checked by a static function because they should not access the object `this` that has been destroyed after the execution of the destructor body). Destructor postconditions are not mentioned in any contract proposal... but together with constructor and other function pre- and postconditions, and together with static class invariants, they can specify contracts for the static part of the object state. For example, consider the contracts for a class that counts the number of its object instances: struct a : private noncopyable, private nonmovable { static void static_invariant() { BOOST_CONTRACT_ASSERT((instances() != 0) == exists()); } a() { boost::contract::old_ptr<unsigned> old_instances = BOOST_CONTRACT_OLDOF(instances()); boost::contract::guard c = boost::contract::constructor(this) .postcondition([&] { BOOST_CONTRACT_ASSERT(instances() == old_instances + 1); }) ; ++instances_; } virtual ~a() { boost::contract::old_ptr<unsigned> old_instances = BOOST_CONTRACT_OLDOF(instances()); boost::contract::guard c = boost::contract::destructor(this) .postcondition([&] { // Must never use object `this`. BOOST_CONTRACT_ASSERT(instances() == old_instances - 1); }) ; --instances_; } static unsigned instances() { boost::contract::guard c = boost::contract::public_function<a>(); return instances_; } static bool exists() { boost::contract::guard c = boost::contract::public_function<a>(); return instances_ != 0; } private: static unsigned instances_; }; unsigned a::instances_ = 0; --Lorenzo

1 0