SO3Any.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
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 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 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, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
// -- Based on boost::any, original copyright information follows --
// 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 --
 
#ifndef __SO3_ANY_H__
#define __SO3_ANY_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "OgreException.h"
#include <algorithm>
#include <typeinfo>
 
namespace SO3
{
 
class SAny 
{
public:
  class placeholder 
  {
  public:
  protected:
  private:
 
  public:
    virtual ~placeholder()
    {
    }
 
    virtual const std::type_info& GetType() const = 0;
 
    virtual placeholder* Clone() const = 0;
  
                virtual void WriteToStream(std::ostream& o) = 0;
  protected:
  private:
  };
 
  template<typename ValueType> class holder : public placeholder
  {
  public:
    ValueType held;
  protected:
  private:
 
  public:
    holder(const ValueType& value) : held(value)
    {
    }
 
    virtual const std::type_info& GetType() const
    {
      return typeid(ValueType);
    }
 
    virtual placeholder* Clone() const
    {
      return new holder(held);
    }
 
                virtual void WriteToStream(std::ostream& o)
                {
                        o << held;
                }
  };
 
protected:
  placeholder* mContent;
  template<typename ValueType> friend ValueType* any_cast(SAny *);
private:
 
public:
  SAny() : mContent(0)
  {
  }
  
  template<typename ValueType> explicit SAny(const ValueType& value) : mContent(new holder<ValueType>(value))
  {
  }
 
  SAny(const SAny& other) : mContent(other.mContent ? other.mContent->Clone() : 0)
  {
  }
 
  virtual ~SAny()
  {
    Destroy();
  }
 
  SAny& Swap(SAny& rhs)
  {
    std::swap(mContent, rhs.mContent);
    return *this;
  }
 
  template<typename ValueType> SAny& operator=(const ValueType& rhs)
  {
    SAny(rhs).Swap(*this);
    return *this;
  }
 
  SAny& operator=(const SAny& rhs)
  {
    SAny(rhs).Swap(*this);
    return *this;
  }
 
  bool IsEmpty() const
  {
    return !mContent;
  }
 
        const std::type_info& GetType() const
  {
    return mContent ? mContent->GetType() : typeid(void);
  }
 
        inline friend std::ostream& operator <<(std::ostream& o, const SAny& v)
        {
                if (v.mContent)
                        v.mContent->WriteToStream(o);
                return o;
        }
 
        void Destroy()
        {
                SO3_SAFE_DELETE(mContent);
        }
 
  template<typename ValueType> ValueType operator()() const
  {
                if(!mContent) 
      OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Bad cast from uninitialised SAny", "SAny::operator()");
                else if(GetType() == typeid(ValueType))
                  return static_cast<SAny::holder<ValueType>*>(mContent)->held;
                else
                {
                        std::ostringstream str;
                        str << "Bad cast from type '" << GetType().name() << "' " << "to '" << typeid(ValueType).name() << "'";
      OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, str.str(),  "SAny::operator()");
                }
        }
};
 
class SAnyNumeric : public SAny
{
public:
protected:
  class numplaceholder : public SAny::placeholder
        {
  public:
  protected:
  private:
 
  public:
    ~numplaceholder()
        {
        }
  
        virtual placeholder* Add(placeholder* rhs) = 0;
  
        virtual placeholder* Subtract(placeholder* rhs) = 0;
        
        virtual placeholder* Multiply(placeholder* rhs) = 0;
        
        virtual placeholder* Multiply(float factor) = 0;
        
        virtual placeholder* Divide(placeholder* rhs) = 0;
  protected:
  private:
        };
 
        template<typename ValueType> class numholder : public numplaceholder
        {
        public:
          ValueType held;
        protected:
        private:
        
        public:  
          numholder(const ValueType& value) : held(value)
                {
                }
 
                virtual const std::type_info& GetType() const
        {
                return typeid(ValueType);
        }
 
    virtual placeholder* Clone() const
    {
                  return new numholder(held);
                }
 
                virtual placeholder* Add(placeholder* rhs)
                {
                        return new numholder(held + static_cast<numholder*>(rhs)->held);
                }
 
    virtual placeholder* Subtract(placeholder* rhs)
                {
                  return new numholder(held - static_cast<numholder*>(rhs)->held);
    }
                
                virtual placeholder* Multiply(placeholder* rhs)
                {
                        return new numholder(held * static_cast<numholder*>(rhs)->held);
                }
                
                virtual placeholder* Multiply(float factor)
                {
                  return new numholder(held * factor);
    }
    
                virtual placeholder* Divide(placeholder* rhs)
                {
                        return new numholder(held / static_cast<numholder*>(rhs)->held);
                }
                
                virtual void WriteToStream(std::ostream& o)
    {
                  o << held;
                }
  protected:
        private:
  };
private:
 
public:
  SAnyNumeric() : SAny()
        {
        }
 
        template<typename ValueType> SAnyNumeric(const ValueType& value)                        
  {
          mContent = new numholder<ValueType>(value);
        }
 
        SAnyNumeric(const SAnyNumeric& other) : SAny()
        {
          mContent = other.mContent ? other.mContent->Clone() : 0; 
  }
 
        SAnyNumeric(placeholder* pholder)
        {
          mContent = pholder;
  }
 
        SAnyNumeric& operator=(const SAnyNumeric& rhs)
        {
                SAnyNumeric(rhs).Swap(*this);
                return *this;
        }
 
  SAnyNumeric operator+(const SAnyNumeric& rhs) const
        {
                return SAnyNumeric(static_cast<numplaceholder*>(mContent)->Add(rhs.mContent));
        }
 
  SAnyNumeric operator-(const SAnyNumeric& rhs) const
        {
                return SAnyNumeric(static_cast<numplaceholder*>(mContent)->Subtract(rhs.mContent));
        }
 
        SAnyNumeric operator*(const SAnyNumeric& rhs) const
        {
                return SAnyNumeric(static_cast<numplaceholder*>(mContent)->Multiply(rhs.mContent));
        }
 
  SAnyNumeric operator*(float factor) const
  {
          return SAnyNumeric(static_cast<numplaceholder*>(mContent)->Multiply(factor));
  }
        
        SAnyNumeric operator/(const SAnyNumeric& rhs) const
        {
                return SAnyNumeric(static_cast<numplaceholder*>(mContent)->Divide(rhs.mContent));
        }
 
        SAnyNumeric& operator+=(const SAnyNumeric& rhs)
  {
          *this = SAnyNumeric(static_cast<numplaceholder*>(mContent)->Add(rhs.mContent));
    return *this;
  }
        
        SAnyNumeric& operator-=(const SAnyNumeric& rhs)
        {
                *this = SAnyNumeric(static_cast<numplaceholder*>(mContent)->Subtract(rhs.mContent));
                return *this;
        }
 
  SAnyNumeric& operator*=(const SAnyNumeric& rhs)
  {
          *this = SAnyNumeric(static_cast<numplaceholder*>(mContent)->Multiply(rhs.mContent));
    return *this;
  }
        
        SAnyNumeric& operator/=(const SAnyNumeric& rhs)
        {
    *this = SAnyNumeric(static_cast<numplaceholder*>(mContent)->Divide(rhs.mContent));
    return *this;
  }
protected:
private:
};
 
template<typename ValueType> ValueType* any_cast(SAny* operand)
{
  if(operand && operand->GetType() == typeid(ValueType))
    return &static_cast<SAny::holder<ValueType>*>(operand->mContent)->held;
  else
    return 0;
}
 
template<typename ValueType> const ValueType* any_cast(const SAny* operand)
{
  return any_cast<ValueType>(const_cast<SAny*>(operand));
}
 
template<typename ValueType> ValueType any_cast(const SAny& operand)
{
  const ValueType* result = any_cast<ValueType>(&operand);
  if(!result)
  {
    std::ostringstream str;
          str << "Bad cast from type '" << operand.GetType().name() << "' " << "to '" << typeid(ValueType).name() << "'";
    OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, str.str(), "any_cast");
  }
  return *result;
}
 
}
 
#endif