// any.tcc // robert - programme du robot 2005. {{{ // // Copyright (C) 2004 Nicolas Schodet // // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. // // Contact : // Web: http://perso.efrei.fr/~schodet/ // Email: // }}} #include "list_ostream_output.hh" #include /// Default constructor. inline any::any (void) : holder_ (0) { } /// Constructor. template any::any (const T &value) : holder_ (new Holder (value)) { } /// Copy constructor. inline any::any (const any &other) : holder_ (other.holder_ ? other.holder_->clone () : 0) { } /// Destructor. inline any::~any (void) { delete holder_; } /// Swap content between two any objects. inline any & any::swap (any &other) { std::swap (holder_, other.holder_); return *this; } /// Copy another any object. inline any & any::operator= (const any &other) { any (other).swap (*this); return *this; } /// Copy another object into this any. template any & any::operator= (const T &value) { any (value).swap (*this); return *this; } /// Test if the any object is empty. inline bool any::empty (void) const { return !holder_; } /// Return the std::type_info of the contained object. inline const std::type_info & any::type (void) const { return holder_ ? holder_->type () : typeid (void); } /// Destructor. inline any::AbstractHolder::~AbstractHolder (void) { } template any::Holder::Holder (const T &value) : value_ (value) { } template const std::type_info & any::Holder::type (void) const { return typeid (T); } template any::AbstractHolder * any::Holder::clone (void) const { return new Holder (value_); } template std::ostream & any::Holder::print (std::ostream &os) const { return os << value_; } /// Return a pointer to the contained object or 0 on faillure. template T * any_cast (any *rhs) { return rhs && rhs->type () == typeid (T) ? &static_cast *> (rhs->holder_)->value_ : 0; } /// Return a const pointer to the contained object or 0 on faillure. template const T * any_cast (const any *rhs) { return any_cast (const_cast (rhs)); } /// Return a const reference to the contained object or throw a bad_any_cast /// on faillure. template const T & any_cast (const any &rhs) { const T *value = any_cast (&rhs); if (!value) throw bad_any_cast (); return *value; } /// Print the contained object. inline std::ostream & operator<< (std::ostream &os, const any &rhs) { return rhs.holder_->print (os); }