HandBooks Professional Java-C-Scrip-SQL part 63 ppsx

Usage The Any library resides in namespace boost. You use the class any to store values, and the template function any_cast to subsequently retrieve the stored values. To use any, include the header "boost/any.hpp". The creation of an instance capable of storing any conceivable value is straightforward. boost::any a; To assign a value of some type is just as easy. a=std::string("A string"); a=42; a=3.1415; Almost anything is acceptable to any! However, to actually do anything with the value contained in an any, we need to retrieve it, right? For that, we need to know the value's type. std::string s=boost::any_cast<std::string>(a); // throws boost::bad_any_cast. This obviously doesn't work; because a currently contains a double, any_cast throws a bad_any_cast exception. The following, however, does work. double d=boost::any_cast<double>(a); any only allows access to the value if you know the type, which is perfectly sensible. These two elements are all you need to remember, typewise, for this library: the class any, for storing the values, and the template function any_cast, to retrieve them. Anything Goes! Consider three classes, A, B, and C, with no common base class, that we'd like to store in a std::vector. If there is no common base class, it would seem we would have to store them as void*, right? Well, not any more (pun intended), because the type of any does not change depending on the type of the value it contains. The following code shows how to solve the problem. #include <iostream> #include <string> #include <utility> #include <vector> #include "boost/any.hpp" class A { public: void some_function() { std::cout << "A::some_function()\n"; } }; class B { public: void some_function() { std::cout << "B::some_function()\n"; } }; class C { public: void some_function() { std::cout << "C::some_function()\n"; } }; int main() { std::cout << "Example of using any.\n\n"; std::vector<boost::any> store_anything; store_anything.push_back(A()); store_anything.push_back(B()); store_anything.push_back(C()); // While we're at it, let's add a few other things as well store_anything.push_back(std::string("This is fantastic! ")); store_anything.push_back(3); store_anything.push_back(std::make_pair(true, 7.92)); void print_any(boost::any& a); // Defined later; reports on the value in a std::for_each( store_anything.begin(), store_anything.end(), print_any); } Running the example produces the following output. Example of using any. A::some_function() B::some_function() C::some_function() string: This is fantastic! Oops! Oops! Great, we can store anything we want, but how do we go about retrieving the values that are stored inside the elements of the vector? In the previous example, we used for_each to call print_any() on each element of the vector. void print_any(boost::any& a) { if (A* pA=boost::any_cast<A>(&a)) { pA->some_function(); } else if (B* pB=boost::any_cast<B>(&a)) { pB->some_function(); } else if (C* pC=boost::any_cast<C>(&a)) { pC->some_function(); } } So far, print_any has tried to retrieve a pointer to an A, B, or C object. This is done with the free function any_cast, which is parameterized on the type to "cast" to. Look closely at the castwe are trying to unlock the any a by saying that we believe that a contains a value with the type A. Also note that we pass our any as a pointer argument to the any_cast function. The return value, therefore, will be a pointer to A, B, or C, respectively. If the any doesn't contain the type that we used in the cast, the null pointer is returned. In the example, if the cast succeeds, we call the some_function member function using the returned pointer. But any_cast can also be used with a slight variation. else { try { std::cout << boost::any_cast<std::string>(a) << '\n'; } catch(boost::bad_any_cast&) { std::cout << "Oops!\n"; } } } Now, this is a bit different. We still perform an any_cast parameterized on the type that we are interested in retrieving, but rather than passing the instance of any as a pointer, it is passed by const reference. This changes the behavior of any_cast; in the case of a failurethat is, asking for the wrong typean exception of type bad_any_cast is thrown. Thus, we have to make sure that we protect the code performing the any_cast with a TRy/catch block if we are not absolutely sure what type of value is contained in the any argument. This behavioral difference (which is analogous with that of dynamic_cast) provides you with a great degree of flexibility. In cases where a cast failure is not an error, pass a pointer to an any, but if a cast failure is an error, pass by const reference, which makes any_cast throw an exception on failure. Using any enables you to use the Standard Library containers and algorithms in situations not heretofore possible, thus allowing you to write more maintainable and understandable code. A Property Class Let's say that we want to define a property class for use in containers. We'll store the names of the properties as strings, and the values can be of any type. Although we could add the requirement that all values be derived from a common base class, that is often not viable. For instance, we may not have access to the source code for all of the classes that we need to use as property values, and some values can be built-in types, which cannot be derived from. (Besides, it wouldn't make for a good any example.) By storing the type of the value in an instance of any, we can leave it to the clients to handle the property values they know about and are interested in. #include <iostream> #include <string> #include <vector> #include <algorithm> #include "boost/any.hpp" class property { boost::any value_; std::string name_; public: property( const std::string& name, const boost::any& value) : name_(name),value_(value) {} std::string name() const { return name_; } boost::any& value() { return value_; } friend bool operator< (const property& lhs, const property& rhs) { return lhs.name_<rhs.name_; } }; This simple property class has a name stored in a std::string for identification, and an any to hold the value. The flexibility that any brings the implementation is that we are able to use built-in types and user-defined types without changing the property class. Be it simple or complex, an instance of any can always store anything. Of course, using any also means that we cannot know in advance that there is some set of operations that can always be performed on the value stored in a propertywe need to retrieve the value first. This implies that if there is a known set of types that are applicable for use with a property class, we may elect to use a different implementation than any. That's a rare situation when designing frameworksif we don't require a certain base class, all we can safely say is that we have absolutely no idea what classes may be sent our way. When you can get any type and don't need to do anything with it but hold it for a while and give it back, you'll find that any is ideal. Notice that the property class provides operator< to allow the class to be stored in Standard Library associative containers; even without that operator, property would work fine with the sequence containers. The following program uses our new and flexiblethanks to any!property class. Instances of the property class are stored in a std::map, where the names of the properties are used as the keys. void print_names(const property& p) { std::cout << p.name() << "\n"; } int main() { std::cout << "Example of using any for storing properties.\n"; std::vector<property> properties; properties.push_back( property("B", 30)); properties.push_back( property("A", std::string("Thirty something"))); properties.push_back(property("C", 3.1415));