Any.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2011, SRI International (R)
 *
 * This program 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 3 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#ifndef __OpenKarto_Any_h__
#define __OpenKarto_Any_h__

#include <algorithm>
#include <typeinfo>

#include <OpenKarto/Exception.h>

namespace karto
{




  // The following code is from the boost library with the following license 
  // and modified to fit into the KartoSDK
  
  // Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
  //
  // Distributed under the Boost Software License, Version 1.0. (See
  // accompAnying file LICENSE_1_0.txt or copy at
  // http://www.boost.org/LICENSE_1_0.txt)
  // -- End original copyright --


  class Any
  {
  public: 
    Any()
      : m_pContent(NULL)
    {
    }

    template<typename T>
    Any(const T& rValue)
      : m_pContent(new Holder<T>(rValue))
    {
    }

    Any(const Any& rOther)
      : m_pContent(rOther.m_pContent ? rOther.m_pContent->Clone() : NULL)
    {
    }

    ~Any()
    {
      delete m_pContent;
    }

  public:
    Any& Swap(Any& rOther)
    {
      std::swap(m_pContent, rOther.m_pContent);
      return *this;
    }

    template<typename T>
    Any & operator=(const T& rOther)
    {
      Any(rOther).Swap(*this);
      return *this;
    }

    Any& operator=(const Any& rOther)
    {
      Any(rOther).Swap(*this);
      return *this;
    }

  public:
    kt_bool IsEmpty() const
    {
      return !m_pContent;
    }

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

  private:
    class PlaceHolder
    {
    public:

      virtual ~PlaceHolder()
      {
      }

    public:
      virtual const std::type_info & GetType() const = 0;

      virtual PlaceHolder * Clone() const = 0;
    };

    template<typename T>
    class Holder : public PlaceHolder
    {
    public:
      Holder(const T & value)
        : held(value)
      {
      }

    public:
      virtual const std::type_info & GetType() const
      {
        return typeid(T);
      }

      virtual PlaceHolder * Clone() const
      {
        return new Holder(held);
      }

    public:
      T held;

    private: 
      Holder & operator=(const Holder &);
    };

  public:
    static const Any Empty;

  private:
    template<typename T>
    friend T * any_cast(Any *);

    PlaceHolder* m_pContent;
  }; // class Any

  template<typename T>
  T * any_cast(Any* pAny)
  {
    return pAny && pAny->GetType() == typeid(T) ? &static_cast<Any::Holder<T> *>(pAny->m_pContent)->held : NULL;
  }

  template<typename T>
  inline const T * any_cast(const Any* pAny)
  {
    return any_cast<T>(const_cast<Any*>(pAny));
  }

  template<typename T>
  inline T any_cast(const Any& rAny)
  {
    const T* pResult = any_cast<T>(&rAny);
    if (!pResult)
    {
      throw karto::Exception("Unable to perform any_cast");
    }

    return *pResult;
  }


}

#endif // __OpenKarto_Any_h__