boost::any - generic type

in statically typed C++

Generic type C++

• C++ is statically typed language
  • type errors are detected during compilation
  • enforces good interfaces for generic classes
  • less bugs
• ...which is good in most cases
• ... but sometimes we want to loosen things up

class Widget {
public:
    // setter per type
    void setProperty(const std::string& name, const std::string& value);
    void setProperty(const std::string& name, const int value);
    void setProperty(const std::string& name, const float value);

    // getter per type - no overloads on return value
    std::string getPropertyS(const std::string& name);
    int         getPropertyI(const std::string& name);
    float       getPropertyF(const std::string& name);
protected:
    std::map<const std::string, std::string> mapS;
    std::map<const std::string, int> mapI;
    std::map<const std::string, float> mapF;
};

class Foo : public Widget {};
class Bar : public Widget {};

int main() {
    Widget* w1 = new Widget();
    Widget* w2 = new Foo();
    Widget* w3 = new Bar();

    w1->setProperty("ratio", 1.0f);
    w2->setProperty("name", std::string("string"));
    //w3->setProperty("names", std::make_pair("test", 1.0f));
}

What we want is ...

class Widget {
public:
    void setProperty(const std::string& name, any value);
    any  getProperty(const std::string& name);
protected:
    std::map<const std::string, any> map;
};

Generic type in C++

• Use generic pointer void*

  struct any {
      void* value;
  };
  

  
  
  • 1st thing you will think of if you written code in C
  • Accepts any kind of pointer
  • Information about type is lost
  • No safe way to check if cast is valid

• Use generic pointer void* + RTTI

  struct any {
      void* value;
      const std::type_info type;
  };
  

  
  
  • Store the typeinfo together with pointer
  • Can check if cast is valid
  • The value is not copyable/assignable
  • Problem with calling the right destructor

• Polymorphism - the Object base class

  struct Object {
      virtual Class   getClass() = 0;
      virtual Object* clone() = 0;
  };
  

  
  
  • Similar to Java Object
  • No single root class hierarchy in C++
  • Will not work with std types
  • Provides safe cast, copying, assignments, safe destructors

boost::any

• Polymorphism + RTTI + templates
  • A wrapper any class
  • Provides safe cast, copying, assignments, safe destructors
  • Works with all types
  • No single root class hierarchy required

The source code CODE

placeholder - the polymorphic part

class placeholder {
public: // structors
    virtual ~placeholder() {}

public: // queries
    virtual const std::type_info & type() const = 0;
    virtual placeholder * clone() const = 0;
};

holder - the template part

template <typename ValueType>
class holder : public placeholder {
public: // structors
    holder(const ValueType & value) : held(value) { }

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

    virtual placeholder * clone() const {
        return new holder(held);
    }

public: // representation
    ValueType held;

private: // intentionally left unimplemented
    holder & operator=(const holder &);
};

boost::any - code

any - the wrapper part

class any {
public: // structors

    any() BOOST_NOEXCEPT
      : content(0)
    { } 
    template<typename ValueType>
    any(const ValueType & value)
      : content(new holder(value))
    { } 
    any(const any & other)
      : content(other.content ? other.content->clone() : 0)
    { } 

    ~any() BOOST_NOEXCEPT
    {
        delete content;
    }

public: // modifiers

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


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

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

public: // queries

    bool empty() const BOOST_NOEXCEPT
    {
        return !content;
    }

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

private: // representation

    template<typename ValueType>
    friend ValueType * any_cast(any *) BOOST_NOEXCEPT;

    template<typename ValueType>
    friend ValueType * unsafe_any_cast(any *) BOOST_NOEXCEPT;

    placeholder * content;
};

any_cast - the casting part

template<typename ValueType>
ValueType * any_cast(any * operand) BOOST_NOEXCEPT {
    return operand &&
        operand->type() == typeid(ValueType)
        ? &static_cast *>(operand->content)->held
        : 0;
}

template<typename ValueType>
ValueType any_cast(any & operand)
{
    typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;

    nonref * result = any_cast(&operand);
    if(!result)
        boost::throw_exception(bad_any_cast());
    return *result;
}

... back to our problem

#include <boost/any.hpp>
#include <string>
#include <map>

using namespace boost;

class Widget {
public:
    void setProperty(const std::string& name, any value);
    any  getProperty(const std::string& name);
protected:
    std::map<const std::string, any> map;
};

class Foo : public Widget {};
class Bar : public Widget {};

int main() {
    Widget* w1 = new Widget();
    Widget* w2 = new Foo();
    Widget* w3 = new Bar();

    w1->setProperty("ratio", 1.0f);
    w2->setProperty("name", std::string("string"));
    w3->setProperty("names", std::make_pair("test", 1.0f));

    boost::any ratio = w1->getProperty("ratio");

    float ratiof = any_cast<float>(ratio);
}

boost::any vs std::any

• Less readable code
• Similar concept - different architecture
  • Dispatch logic to any::_Manager_internal<T>
  • Operations:
    _Op_access, _Op_clone, _Op_destroy, etc
• Works also with RTTI disabled
  • Unique manager per type
  • Compare manager function addresses instead of type_info

Thank you