collaborator.h

Go to the documentation of this file.

/*******************************************************************************
 * wallaroo - A library for configurable creation and wiring of C++ classes.
 * Copyright (C) 2012 Daniele Pallastrelli
 *
 * This file is part of wallaroo.
 * For more information, see http://wallaroolib.sourceforge.net/
 *
 * Boost Software License - Version 1.0 - August 17th, 2003
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 *
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ******************************************************************************/

#ifndef WALLAROO_COLLABORATOR_H_
#define WALLAROO_COLLABORATOR_H_

#include <string>
#include <typeinfo>
#include <vector>
#include "cxx0x.h"
#include "dependency.h"
#include "part.h"
#include "exceptions.h"

namespace wallaroo
{


    namespace detail
    {

        // overloaded utility function to get a shared_ptr from one of shared_ptr, weak_ptr

        template < typename T >
        cxx0x::shared_ptr< T > GetShared( const cxx0x::shared_ptr< T >& s ) { return s; }

        template < typename T >
        cxx0x::shared_ptr< T > GetShared( const cxx0x::weak_ptr< T >& s )
        {
            if ( cxx0x::shared_ptr< T > result = s.lock() ) return result;
            throw DeletedPartError();
        }

        // overloaded utility function to check in uniform way both shared_ptr and weak_ptr

        template < typename T >
        bool NotEmpty( const cxx0x::shared_ptr< T >& p ) { return static_cast<bool>( p ); }

        template < typename T >
        bool NotEmpty( const cxx0x::weak_ptr< T >& p ) { return !p.expired(); }

    }


struct optional
{
    template < typename T > static bool WiringOk( const T& ) { return true; }
};
struct mandatory
{
    template < typename T > static bool WiringOk( const cxx0x::weak_ptr< T >& t ) { return !t.expired(); }
    template < typename T > static bool WiringOk( const cxx0x::shared_ptr< T >& t ) { return static_cast< bool >( t ); }
};
template <     
    std::size_t MIN = 0,
    std::size_t MAX = 0,
    template < typename E, typename Allocator = std::allocator< E > > class C = std::vector
>
struct bounded_collection
{
    template < typename T >
    static bool WiringOk( const T* t )
    {
        const std::size_t s = t -> size();
        return ( s >= MIN && ( MAX == 0 || s <= MAX ) );
    }
    template < typename T > struct Container { typedef C< T > Type;  };
};
// template specializations to avoid warning about "unsigned is always >= 0":
template < std::size_t MAX, template < typename E, typename Allocator = std::allocator< E > > class C >
struct bounded_collection< 0, MAX, C >
{
    template < typename T >
    static bool WiringOk( const T* t ) { return ( t -> size() <= MAX ); }
    template < typename T > struct Container { typedef C< T > Type; };
};
template < std::size_t MIN, template < typename E, typename Allocator = std::allocator< E > > class C >
struct bounded_collection< MIN, 0, C >
{
    template < typename T >
    static bool WiringOk( const T* t ) { return ( t -> size() >= MIN ); }
    template < typename T > struct Container { typedef C< T > Type; };
};
template < template < typename E, typename Allocator = std::allocator< E > > class C >
struct bounded_collection< 0, 0, C >
{
    template < typename T >
    static bool WiringOk( const T* ) { return true; }
    template < typename T > struct Container { typedef C< T > Type; };
};
template < template < typename E, typename Allocator = std::allocator< E > > class C = std::vector >
struct collection
{
    template < typename T > static bool WiringOk( const T* ) { return true; }
    template < typename T > struct Container { typedef C< T > Type; };
};




template <
    typename T,
    typename P = mandatory,
    template < typename X > class Ownership = cxx0x::weak_ptr
>
class Collaborator : public Dependency
{
public:

    typedef Ownership< T > Ptr;
    typedef cxx0x::shared_ptr< T > SharedPtr;

    Collaborator( const std::string& name, const RegToken& token )
    {
        Part* owner = token.GetPart();
        owner -> Register( name, this );
    }

    void Link( const cxx0x::shared_ptr< Part >& dev )
    {
        if ( cxx0x::shared_ptr< T > _dev = cxx0x::dynamic_pointer_cast< T >( dev ) )
            part = _dev;
        else // bad type!
            throw WrongType();
    }

    SharedPtr operator -> () { return detail::GetShared( part ); }

    const SharedPtr operator -> () const { return detail::GetShared( part ); }

    operator SharedPtr() { return detail::GetShared( part ); }

    operator const SharedPtr() const { return detail::GetShared( part ); }
    
    operator bool() const { return detail::NotEmpty( part ); }

    virtual bool WiringOk() const { return P::WiringOk( part ); }

private:
    Ptr part;

    // copy ctor and assignment operator disabled
    Collaborator( const Collaborator& );
    Collaborator& operator = ( const Collaborator& );
};


// partial specialization for the collection case
template <
    typename T,
    std::size_t MIN,
    std::size_t MAX,
    template < typename E, typename Allocator = std::allocator< E > > class C,
    template < typename X > class Ownership
>
class Collaborator< T, bounded_collection< MIN, MAX, C >, Ownership > : 
    public Dependency,
    public bounded_collection< MIN, MAX, C >::template Container< Ownership< T > >::Type
{
private:
    typedef Ownership< T > Ptr;
    typedef typename bounded_collection< MIN, MAX, C >::template Container< Ptr >::Type Cont;

public:

    Collaborator( const std::string& name, const RegToken& token )
    {
        Part* owner = token.GetPart();
        owner -> Register( name, this );
    }

    void Link( const cxx0x::shared_ptr< Part >& part )
    {
        if ( cxx0x::shared_ptr< T > obj = cxx0x::dynamic_pointer_cast< T >( part ) )
            Cont::push_back( obj );
        else
            throw WrongType(); // bad type!
    }

    virtual bool WiringOk() const
    {
        return bounded_collection< MIN, MAX, C >::WiringOk( this );
    }

private:
    // copy ctor and assignment operator disabled
    Collaborator( const Collaborator& );
    Collaborator& operator = ( const Collaborator& );
};

// partial specialization for the collection case
template <
    typename T,
    template < typename E, typename Allocator = std::allocator< E > > class C,
    template < typename X > class Ownership
>
class Collaborator< T, collection< C >, Ownership > : 
    public Collaborator < T, bounded_collection< 0, 0, C >, Ownership >
{
public:
    Collaborator( const std::string& name, const RegToken& token ) :
        Collaborator < T, bounded_collection< 0, 0, C >, Ownership >( name, token )
    {}
};

}

#endif