Any.hpp

Go to the documentation of this file.

#pragma ident "$Id: Any.hpp 2938 2011-10-23 19:39:11Z yanweignss $"

#ifndef GPSTK_ANY_HPP
#define GPSTK_ANY_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk 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 Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  Wei Yan - Chinese Academy of Sciences . 2011
//
//============================================================================

#include <algorithm>
#include <typeinfo>
#include "Exception.hpp"

namespace gpstk
{
   class Any
   {
   public:
      Any():_content(0){}

      template <typename ValueType>
      Any(const ValueType& value):_content(new Holder<ValueType>(value)) {}

      Any(const Any& other):_content(other._content ? other._content->clone() : 0){}

      ~Any(){delete _content;}

      Any& swap(Any& rhs)
      {
         std::swap(_content, rhs._content);
         return *this;
      }

      template <typename ValueType>
      Any& operator = (const ValueType& rhs)
      {
         Any(rhs).swap(*this);
         return *this;
      }

      Any& operator = (const Any& rhs)
      {
         Any(rhs).swap(*this);
         return *this;
      }

      bool empty() const
      {
         return !_content;
      }

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

   private:
      class Placeholder
      {
      public:
         virtual ~Placeholder(){}

         virtual const std::type_info& type() const = 0;
         virtual Placeholder* clone() const = 0;
      };

      template <typename ValueType>
      class Holder: public Placeholder
      {
      public: 
         Holder(const ValueType& value):_held(value){}

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

         virtual Placeholder* clone() const
         {
            return new Holder(_held);
         }

         ValueType _held;
      };

   private:
      template <typename ValueType>
      friend ValueType* AnyCast(Any*);

      template <typename ValueType>
      friend ValueType* UnsafeAnyCast(Any*);

      Placeholder* _content;
   };


   template <typename ValueType>
   ValueType* AnyCast(Any* operand)
   {
      return operand && operand->type() == typeid(ValueType)
         ? &static_cast<Any::Holder<ValueType>*>(operand->_content)->_held
         : 0;
   }


   template <typename ValueType>
   const ValueType* AnyCast(const Any* operand)     
   {
      return AnyCast<ValueType>(const_cast<Any*>(operand));
   }


   template <typename ValueType>
   ValueType AnyCast(const Any& operand)
   {
      ValueType* result = AnyCast<ValueType>(const_cast<Any*>(&operand));
      if (!result) throw Exception("Failed to convert between const Any types");
      return *result;
   }

   template <typename ValueType>
   ValueType AnyCast(Any& operand)
   {
      ValueType* result = AnyCast<ValueType>(&operand);
      if (!result) throw Exception("Failed to convert between Any types");
      return *result;
   }

   template <typename ValueType>
   const ValueType& RefAnyCast(const Any & operand)
   {
      ValueType* result = AnyCast<ValueType>(const_cast<Any*>(&operand));
      if (!result) throw Exception("RefAnyCast: Failed to convert between const Any types");
      return *result;
   }


   template <typename ValueType>
   ValueType& RefAnyCast(Any& operand)
   {
      ValueType* result = AnyCast<ValueType>(&operand);
      if (!result) throw Exception("RefAnyCast: Failed to convert between Any types");
      return *result;
   }

   template <typename ValueType>
   ValueType* UnsafeAnyCast(Any* operand)    
   {
      return &static_cast<Any::Holder<ValueType>*>(operand->_content)->_held;
   }

   template <typename ValueType>
   const ValueType* UnsafeAnyCast(const Any* operand)
   {
      return AnyCast<ValueType>(const_cast<Any*>(operand));
   }
   
}   // End of namespace gpstk


#endif  //GPSTK_ANY_HPP

---