bbtkAny.h

Go to the documentation of this file.

/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbtkAny.h,v $
  Language:  C++
  Date:      $Date: 2010/01/14 13:17:27 $
  Version:   $Revision: 1.8 $
=========================================================================*/

/* ---------------------------------------------------------------------

* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
*  This software is governed by the CeCILL-B license under French law and 
*  abiding by the rules of distribution of free software. You can  use, 
*  modify and/ or redistribute the software under the terms of the CeCILL-B 
*  license as circulated by CEA, CNRS and INRIA at the following URL 
*  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
*  or in the file LICENSE.txt.
*
*  As a counterpart to the access to the source code and  rights to copy,
*  modify and redistribute granted by the license, users are provided only
*  with a limited warranty  and the software's author,  the holder of the
*  economic rights,  and the successive licensors  have only  limited
*  liability. 
*
*  The fact that you are presently reading this means that you have had
*  knowledge of the CeCILL-B license and that you accept its terms.
* ------------------------------------------------------------------------ */                                                                         


#ifndef __BBTKANY_H_INCLUDED__
#define __BBTKANY_H_INCLUDED__

/*
#include <string>
#include <iostream>
#include <typeinfo>
#include <set>
#include <map>
#include <sstream>
#include <exception>

#include <cxxabi.h>
*/
#include <sstream>
#include "bbtkRTTI.h"
#include "bbtkMessageManager.h"
#include "bbtkException.h"

#include <boost/type_traits/is_pointer.hpp>

namespace bbtk 
{





  //=========================================================
  class anyplaceholder
  {
  public: // structors
    
    virtual ~anyplaceholder() {}
    
  public: // queries
    
    virtual const std::type_info & type() const = 0;
    virtual const std::type_info & pointed_type() const = 0;
    
    virtual bool is_pointer() const = 0;
    
    virtual void* get_pointer() const = 0;
 
    virtual void* get_pointer_to( const std::type_info& ) const = 0;
   
    virtual anyplaceholder * clone() const = 0;
    
  };
  //=========================================================
  
  //=========================================================
  template<typename ValueType>
  class anyholder : public anyplaceholder
  {
  public: // structors
    
    anyholder(const ValueType & value)
      : held(value)
    {}
    
  public: // queries
    
    virtual const std::type_info & type() const { return typeid(ValueType);}
    virtual bool is_pointer() const { return false; }
    virtual const std::type_info & pointed_type() const { return typeid(void); }
    virtual void* get_pointer() const { return 0; }
    virtual void* get_pointer_to( const std::type_info& ) const { return 0; }
    virtual anyplaceholder * clone() const { return new anyholder(held); }
    
    public: // representation
    
    ValueType held;
    
  };
  //=========================================================
  
  //=========================================================
  template<typename ValueType>
  class anyholder<ValueType*> : public anyplaceholder
  {
  public: // structors

    anyholder(ValueType* const & value)
      : held(value)
    { }

  public: // queries

    virtual const std::type_info & type() const
    {
      return typeid(ValueType*);
    }

    virtual bool is_pointer() const { return true; }
    virtual const std::type_info & pointed_type() const { return typeid(ValueType); }
    virtual void* get_pointer() const { 
      return (void*)held; 
    }
    virtual void* get_pointer_to( const std::type_info& t) const 
    { 
      return run_time_up_or_down_cast(t,typeid(ValueType),held);
    }

    virtual anyplaceholder * clone() const { return new anyholder(held); }

  public: // representation

    ValueType* held;

  };
  //=========================================================


  template <template <class> class TypeTraits >
  class any
  {
  public:
    typedef any< TypeTraits > self;
    // structors

    any()
      : content(0)
    {
    }

    template<typename ValueType>
    any(const ValueType & value)
      : content(0)
    {
      bbtkDebugMessage("Data",1,
                       bbtk::HumanTypeName<self>()<<" construction with <"
                       <<bbtk::HumanTypeName<ValueType>()<<">"<<std::endl);
      //      ValueType v = value;
      //      int** i = (int**)(&v);
      //      std::cout << "v="<<*i<<std::endl;
      
      if (accepts<ValueType>()) 
        { 
          content = new anyholder<ValueType>(value);
        }
      else 
        {
          bbtkError(bbtk::HumanTypeName<self>()
                    <<" constructor : data of type <"
                    <<bbtk::HumanTypeName<ValueType>()
                    <<"> are not accepted by traits <"
                    <<bbtk::HumanTypeName<TypeTraits<void> >()<<"> ");
        }
    }
  
    any(const any & other)
      : content(other.content ? other.content->clone() : 0)
    {
      bbtkDebugMessage("Data",1,
                       HumanTypeName<self>()
                       <<" copy construction with new content : "
                       <<HumanTypeName(type())
                       <<std::endl);
    }
  
    ~any()
    {
      delete content;
    }


    any & swap(any & rhs)
    {
      std::swap(content, rhs.content);
      return *this;
    }

    template<typename ValueType>
    any & operator=(const ValueType & rhs)
    {
      bbtkDebugMessage("Data",1,
                       HumanTypeName<self>()
                       <<" operator= with data of type <"
                       <<HumanTypeName<ValueType>()
                       <<">"<<std::endl);
      if (accepts<ValueType>()) 
        {
          any(rhs).swap(*this);
          return *this;
        }
      else 
        {
          bbtkError(HumanTypeName<self>()
                    <<" operator= : data of type <"
                    <<HumanTypeName<ValueType>()
                    <<"> are not accepted by traits <"
                    <<HumanTypeName<TypeTraits<void> >()<<"> ");
        }
    
    }
  
    any & operator=(const any & rhs)
    {
        bbtkDebugMessage("Data",1,
                         HumanTypeName<self >()
                         <<" operator=(const any&) with content : "
                         <<HumanTypeName(rhs.type())<<std::endl);

      any(rhs).swap(*this);
      return *this;
    }
  

    bool empty() const
    {
      return !content;
    }
  
    const std::type_info & type() const
    {
      return content ? content->type() : typeid(void);
    }

    const std::type_info & pointed_type() const
    {
      return content ? content->pointed_type() : typeid(void);
    }


    template<typename Type>
    inline bool contains()
    {
      return ( type() == typeid(Type) );
    }

    inline bool contains_pointer()
    {
      return content ? content->is_pointer() : false;
    }

    inline bool contains(TypeInfo t)
    {
      return ( (bool)((type() == t)!=0) );
     }

    template<typename Type>
    inline bool accepts()
    {
      return TypeTraits<Type>::value; //is_valid();
    }

    template<typename ValueType>
    inline const ValueType& get() const
    {
        bbtkDebugMessage("Data",1,
                         HumanTypeName<self >()
                         <<" get<"<<HumanTypeName<ValueType>()
                         <<"> with content : "
                         <<HumanTypeName(type())<<std::endl);

      if ( type() == typeid(ValueType) )
        return static_cast< anyholder<ValueType> *>(content)->held;

      bbtkError(HumanTypeName<self >()
                <<" get with type <"
                <<bbtk::HumanTypeName<ValueType>()
                <<"> does not match content type <"
                <<bbtk::HumanTypeName<>(type())<<">");
    }

    template<typename ValueType>
    inline const ValueType* getP() const
    {
      if ( type() == typeid(ValueType) )
        return &static_cast< anyholder<ValueType> *>(content)->held;
 
      bbtkError(HumanTypeName<self >()
                <<" getP with type <"
                <<bbtk::HumanTypeName<ValueType>()
                <<"> does not match content type <"
                <<bbtk::HumanTypeName<>(type())<<">");
    }

    template<typename ValueType>
    inline const ValueType& unsafe_get() const
    {
        bbtkDebugMessage("Data",1,
                         HumanTypeName<self>()
                         <<"::unsafe_get<"
                         <<HumanTypeName<ValueType>()<<"> with content : "
                         <<HumanTypeName(this->type())
                         <<std::endl);

        //      PrintValueIfIsPointer<ValueType>(static_cast< anyholder<ValueType> * >(content)->held);
        //      int** i = (int**)(&static_cast< anyholder<ValueType> * >(content)->held);
        //      std::cout << "v="<<*i<<std::endl;

        if (content) 
          return static_cast< anyholder<ValueType> * >(content)->held;
        
        bbtkError(HumanTypeName<self >()
                  <<"::usafe_get<"
                  <<bbtk::HumanTypeName<ValueType>()
                  <<"> : void content");
    }


    inline void* get_pointer() const 
    {
      void* p = content->get_pointer();
      bbtkDebugMessage("Data",1,
                       HumanTypeName<self>()
                       <<"::get_pointer() with content <"
                       <<HumanTypeName(this->type())
                       <<"> : result = "
                       << p
                       <<std::endl);
      return p;
    }
    
    inline void* get_pointer_to(const std::type_info& t) const 
    {
      void* p = content->get_pointer_to(t);
      bbtkDebugMessage("Data",1,
                       HumanTypeName<self>()
                       <<"::get_pointer_to("<<HumanTypeName(t)
                       <<") with content <"
                       <<HumanTypeName(this->type())
                       <<"> : result = "
                       << p
                       <<std::endl);
      return p;
    }
    
  private: 
    anyplaceholder * content;
    
  };

  

  template <typename T> struct thing { static const bool value = true; };

  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(bbtk::any<bbtk::thing>,"anything");


  template <typename T> struct integer { static const bool value; };
  template <class T> const bool integer<T>::value = false;

  template <typename T> struct floating_point { static const bool value; };
  template <class T> const bool floating_point<T>::value = false;


  template <typename T> struct number { static const bool value; };
  template <class T> const bool number<T>::value = 
             integer<T>::value || floating_point<T>::value ;
  
  
#define BBTK_DECLARE_TYPE_TRAITS(NAME)                                  \
  template <typename T> struct NAME { static const bool value; };       \
    template <class T> const bool NAME<T>::value = false;
  
#define BBTK_ADD_TO_TYPE_TRAITS(NAME,TYPE)      \
  template <> bool NAME<TYPE>::value = true;


}





#endif