kernel/src/bbtkAny.h

   1 /*=========================================================================
   2   Program:   bbtk
   3   Module:    $RCSfile: bbtkAny.h,v $
   4   Language:  C++
   5   Date:      $Date: 2010/01/14 13:17:27 $
   6   Version:   $Revision: 1.8 $
   7 =========================================================================*/
   8
   9 /* ---------------------------------------------------------------------
  10
  11 * Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
  12 * Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
  13 *
  14 *  This software is governed by the CeCILL-B license under French law and
  15 *  abiding by the rules of distribution of free software. You can  use,
  16 *  modify and/ or redistribute the software under the terms of the CeCILL-B
  17 *  license as circulated by CEA, CNRS and INRIA at the following URL
  18 *  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  19 *  or in the file LICENSE.txt.
  20 *
  21 *  As a counterpart to the access to the source code and  rights to copy,
  22 *  modify and redistribute granted by the license, users are provided only
  23 *  with a limited warranty  and the software's author,  the holder of the
  24 *  economic rights,  and the successive licensors  have only  limited
  25 *  liability.
  26 *
  27 *  The fact that you are presently reading this means that you have had
  28 *  knowledge of the CeCILL-B license and that you accept its terms.
  29 * ------------------------------------------------------------------------ */
  30
  31
  32 /**
  33  *\file
  34  *\brief  Defines the class any which can store any type of data (adapted from boost::any).
  35  */
  36 #ifndef __BBTKANY_H_INCLUDED__
  37 #define __BBTKANY_H_INCLUDED__
  38
  39 /*
  40 #include <string>
  41 #include <iostream>
  42 #include <typeinfo>
  43 #include <set>
  44 #include <map>
  45 #include <sstream>
  46 #include <exception>
  47
  48 #include <cxxabi.h>
  49 */
  50 #include <sstream>
  51 #include "bbtkRTTI.h"
  52 #include "bbtkMessageManager.h"
  53 #include "bbtkException.h"
  54
  55 #include <boost/type_traits/is_pointer.hpp>
  56
  57 namespace bbtk
  58 {
  59
  60
  61
  62
  63
  64   //=========================================================
  65   /// Abstract class used by the any class to store values
  66   class anyplaceholder
  67   {
  68   public: // structors
  69
  70     virtual ~anyplaceholder() {}
  71
  72   public: // queries
  73
  74     /// returns the type of the held value
  75     virtual const std::type_info & type() const = 0;
  76     /// returns the type of the pointed held value
  77     virtual const std::type_info & pointed_type() const = 0;
  78
  79     /// returns true iff the stored value is a pointer
  80     virtual bool is_pointer() const = 0;
  81
  82     /// If the held value is a pointer then
  83     /// returns its value
  84     virtual void* get_pointer() const = 0;
  85
  86     ///
  87     virtual void* get_pointer_to( const std::type_info& ) const = 0;
  88
  89     virtual anyplaceholder * clone() const = 0;
  90
  91   };
  92   //=========================================================
  93
  94   //=========================================================
  95   /// Concrete template class used by the any class to store values
  96   /// which stores a value of type ValueType
  97   template<typename ValueType>
  98   class anyholder : public anyplaceholder
  99   {
 100   public: // structors
 101
 102     anyholder(const ValueType & value)
 103       : held(value)
 104     {}
 105
 106   public: // queries
 107
 108     virtual const std::type_info & type() const { return typeid(ValueType);}
 109     virtual bool is_pointer() const { return false; }
 110     virtual const std::type_info & pointed_type() const { return typeid(void); }
 111     virtual void* get_pointer() const { return 0; }
 112     virtual void* get_pointer_to( const std::type_info& ) const { return 0; }
 113     virtual anyplaceholder * clone() const { return new anyholder(held); }
 114
 115     public: // representation
 116
 117     ValueType held;
 118
 119   };
 120   //=========================================================
 121
 122   //=========================================================
 123   /// specialization of anyholder for pointer types
 124   template<typename ValueType>
 125   class anyholder<ValueType*> : public anyplaceholder
 126   {
 127   public: // structors
 128
 129     anyholder(ValueType* const & value)
 130       : held(value)
 131     { }
 132
 133   public: // queries
 134
 135     virtual const std::type_info & type() const
 136     {
 137       return typeid(ValueType*);
 138     }
 139
 140     virtual bool is_pointer() const { return true; }
 141     virtual const std::type_info & pointed_type() const { return typeid(ValueType); }
 142     virtual void* get_pointer() const {
 143       return (void*)held;
 144     }
 145     virtual void* get_pointer_to( const std::type_info& t) const
 146     {
 147       return run_time_up_or_down_cast(t,typeid(ValueType),held);
 148     }
 149
 150     virtual anyplaceholder * clone() const { return new anyholder(held); }
 151
 152   public: // representation
 153
 154     ValueType* held;
 155
 156   };
 157   //=========================================================
 158
 159
 160   /** A magic class which can store any type of data which
 161    * is allowed by the template template parameter TypeTrait.
 162    *
 163    * The only requirement on TypeTrait<T> is to have the member :
 164    *    static const bool value;
 165    * which is true iff the type T is an allowed type
 166    *
 167    * TypeTraits compliant objects are usually template structs
 168    * for which the initialisation of value is set to false by default
 169    * and set to true for the allowed types (template specialisation)
 170    * Example :
 171    *   template <typename T> struct mytypes { static const bool value; };
 172    *   template <typename T> const bool mytypes<T>::value = false;
 173    *   template <> const bool mytypes<int>::value = true;
 174    *   template <> const bool mytypes<float>::value = true;
 175    * etc.
 176    * You can use any boost type_trait, like is_pointer, is_floating_point, etc.
 177    *
 178    * The class any is a generalisation of the boost::any class
 179    * (see http://www.boost.org/doc/html/any.html).
 180    * The boost::any class itself is reproduced by any<thing>,
 181    * where thing is a TypeTrait whose value is true for all types.
 182    **/
 183   template <template <class> class TypeTraits >
 184   class any
 185   {
 186   public:
 187     typedef any< TypeTraits > self;
 188     // structors
 189
 190     /// Default constructor
 191     any()
 192       : content(0)
 193     {
 194     }
 195
 196     /// Constructor with a value of template type
 197     template<typename ValueType>
 198     any(const ValueType & value)
 199       : content(0)
 200     {
 201       bbtkDebugMessage("Data",1,
 202                        bbtk::HumanTypeName<self>()<<" construction with <"
 203                        <<bbtk::HumanTypeName<ValueType>()<<">"<<std::endl);
 204       //      ValueType v = value;
 205       //      int** i = (int**)(&v);
 206       //      std::cout << "v="<<*i<<std::endl;
 207
 208       if (accepts<ValueType>())
 209         {
 210           content = new anyholder<ValueType>(value);
 211         }
 212       else
 213         {
 214           bbtkError(bbtk::HumanTypeName<self>()
 215                     <<" constructor : data of type <"
 216                     <<bbtk::HumanTypeName<ValueType>()
 217                     <<"> are not accepted by traits <"
 218                     <<bbtk::HumanTypeName<TypeTraits<void> >()<<"> ");
 219         }
 220     }
 221
 222     /// Copy constructor
 223     any(const any & other)
 224       : content(other.content ? other.content->clone() : 0)
 225     {
 226       bbtkDebugMessage("Data",1,
 227                        HumanTypeName<self>()
 228                        <<" copy construction with new content : "
 229                        <<HumanTypeName(type())
 230                        <<std::endl);
 231     }
 232
 233     /// Destructor
 234     ~any()
 235     {
 236       delete content;
 237     }
 238
 239
 240     /// Swaps the content of this with another any
 241     any & swap(any & rhs)
 242     {
 243       std::swap(content, rhs.content);
 244       return *this;
 245     }
 246
 247     /// Affectation of a value of template type
 248     template<typename ValueType>
 249     any & operator=(const ValueType & rhs)
 250     {
 251       bbtkDebugMessage("Data",1,
 252                        HumanTypeName<self>()
 253                        <<" operator= with data of type <"
 254                        <<HumanTypeName<ValueType>()
 255                        <<">"<<std::endl);
 256       if (accepts<ValueType>())
 257         {
 258           any(rhs).swap(*this);
 259           return *this;
 260         }
 261       else
 262         {
 263           bbtkError(HumanTypeName<self>()
 264                     <<" operator= : data of type <"
 265                     <<HumanTypeName<ValueType>()
 266                     <<"> are not accepted by traits <"
 267                     <<HumanTypeName<TypeTraits<void> >()<<"> ");
 268         }
 269
 270     }
 271
 272     /// Affectation of another any
 273     any & operator=(const any & rhs)
 274     {
 275         bbtkDebugMessage("Data",1,
 276                          HumanTypeName<self >()
 277                          <<" operator=(const any&) with content : "
 278                          <<HumanTypeName(rhs.type())<<std::endl);
 279
 280       any(rhs).swap(*this);
 281       return *this;
 282     }
 283
 284
 285     /// Is it empty (no value held) ?
 286     bool empty() const
 287     {
 288       return !content;
 289     }
 290
 291     /// Returns the type_info of the held value
 292     const std::type_info & type() const
 293     {
 294       return content ? content->type() : typeid(void);
 295     }
 296
 297     /// Returns the type_info of the pointed held value
 298     const std::type_info & pointed_type() const
 299     {
 300       return content ? content->pointed_type() : typeid(void);
 301     }
 302
 303
 304     /// Returns true iff the contained type is Type
 305     template<typename Type>
 306     inline bool contains()
 307     {
 308       return ( type() == typeid(Type) );
 309     }
 310
 311     /// Returns true iff the contained type is a pointer
 312     inline bool contains_pointer()
 313     {
 314       return content ? content->is_pointer() : false;
 315     }
 316
 317     /// Returns true iff the contained type is t
 318     inline bool contains(TypeInfo t)
 319     {
 320       return ( (bool)((type() == t)!=0) );
 321      }
 322
 323     /// Returns true iff any of type ValueType can be held
 324     template<typename Type>
 325     inline bool accepts()
 326     {
 327       return TypeTraits<Type>::value; //is_valid();
 328     }
 329
 330     /// Returns a const reference on the held value iff its type matches
 331     /// the template parameter
 332     template<typename ValueType>
 333     inline const ValueType& get() const
 334     {
 335         bbtkDebugMessage("Data",1,
 336                          HumanTypeName<self >()
 337                          <<" get<"<<HumanTypeName<ValueType>()
 338                          <<"> with content : "
 339                          <<HumanTypeName(type())<<std::endl);
 340
 341       if ( type() == typeid(ValueType) )
 342         return static_cast< anyholder<ValueType> *>(content)->held;
 343
 344       bbtkError(HumanTypeName<self >()
 345                 <<" get with type <"
 346                 <<bbtk::HumanTypeName<ValueType>()
 347                 <<"> does not match content type <"
 348                 <<bbtk::HumanTypeName<>(type())<<">");
 349     }
 350
 351     template<typename ValueType>
 352     inline const ValueType* getP() const
 353     {
 354       if ( type() == typeid(ValueType) )
 355         return &static_cast< anyholder<ValueType> *>(content)->held;
 356
 357       bbtkError(HumanTypeName<self >()
 358                 <<" getP with type <"
 359                 <<bbtk::HumanTypeName<ValueType>()
 360                 <<"> does not match content type <"
 361                 <<bbtk::HumanTypeName<>(type())<<">");
 362     }
 363
 364     /// Returns a const reference on the held value
 365     /// ** EVEN IF ITS TYPE DOES NOT MATCH THE TEMPLATE PARAMETER **
 366     /// Hence must be used when one knows that the type is good
 367     /// Otherwise can lead to unpredictible results
 368     template<typename ValueType>
 369     inline const ValueType& unsafe_get() const
 370     {
 371         bbtkDebugMessage("Data",1,
 372                          HumanTypeName<self>()
 373                          <<"::unsafe_get<"
 374                          <<HumanTypeName<ValueType>()<<"> with content : "
 375                          <<HumanTypeName(this->type())
 376                          <<std::endl);
 377
 378         //      PrintValueIfIsPointer<ValueType>(static_cast< anyholder<ValueType> * >(content)->held);
 379         //      int** i = (int**)(&static_cast< anyholder<ValueType> * >(content)->held);
 380         //      std::cout << "v="<<*i<<std::endl;
 381
 382         if (content)
 383           return static_cast< anyholder<ValueType> * >(content)->held;
 384
 385         bbtkError(HumanTypeName<self >()
 386                   <<"::usafe_get<"
 387                   <<bbtk::HumanTypeName<ValueType>()
 388                   <<"> : void content");
 389     }
 390
 391
 392     inline void* get_pointer() const
 393     {
 394       void* p = content->get_pointer();
 395       bbtkDebugMessage("Data",1,
 396                        HumanTypeName<self>()
 397                        <<"::get_pointer() with content <"
 398                        <<HumanTypeName(this->type())
 399                        <<"> : result = "
 400                        << p
 401                        <<std::endl);
 402       return p;
 403     }
 404
 405     inline void* get_pointer_to(const std::type_info& t) const
 406     {
 407       void* p = content->get_pointer_to(t);
 408       bbtkDebugMessage("Data",1,
 409                        HumanTypeName<self>()
 410                        <<"::get_pointer_to("<<HumanTypeName(t)
 411                        <<") with content <"
 412                        <<HumanTypeName(this->type())
 413                        <<"> : result = "
 414                        << p
 415                        <<std::endl);
 416       return p;
 417     }
 418
 419   private:
 420     /// content
 421     anyplaceholder * content;
 422
 423   };
 424
 425
 426
 427   /// The TypeTraits which validates any type
 428   template <typename T> struct thing { static const bool value = true; };
 429
 430   BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(bbtk::any<bbtk::thing>,"anything");
 431
 432
 433   /// The TypeTraits which validates all integer types
 434   template <typename T> struct integer { static const bool value; };
 435   template <class T> const bool integer<T>::value = false;
 436
 437   /// The TypeTraits which validates all floating point number types
 438   template <typename T> struct floating_point { static const bool value; };
 439   template <class T> const bool floating_point<T>::value = false;
 440
 441
 442   /// The TypeTraits which validates all numerical types
 443   template <typename T> struct number { static const bool value; };
 444   template <class T> const bool number<T>::value =
 445              integer<T>::value || floating_point<T>::value ;
 446
 447
 448   /// Macro to begin the enumeration of types included into a
 449   /// any_type_collection previously declared with
 450   /// DECLARE_any_type_collection.
 451   /// Must be placed in the implementation part of the code.
 452 #define BBTK_DECLARE_TYPE_TRAITS(NAME)                                  \
 453   template <typename T> struct NAME { static const bool value; };       \
 454     template <class T> const bool NAME<T>::value = false;
 455
 456 #define BBTK_ADD_TO_TYPE_TRAITS(NAME,TYPE)      \
 457   template <> bool NAME<TYPE>::value = true;
 458
 459
 460 }
 461
 462
 463
 464
 465
 466 #endif
 467