messages.hpp

#ifndef MESSAGE_FOR_EXEC_HPP
#define MESSAGE_FOR_EXEC_HPP

#include "parallel.hpp"
#include <string>
#include "shared_ptr.hpp"

class loadable_Object;
typedef STD_TR1::shared_ptr<loadable_Object> loadable_Object_ref;

class executable_Object;
typedef STD_TR1::shared_ptr<executable_Object> executable_Object_ref;


class message{
public:
    typedef STD_TR1::shared_ptr<message> ref;

    explicit message( const std::string& param_name,
              loadable_Object_ref parameters,
              loadable_Object_ref receiver);
    virtual ~message(){};

    void prepare_message( size_t N, const std::string& filen);
    void deliver_message(MPI_Comm comm, size_t loop_nr) const;
    void close_message(MPI_Comm comm){ close_message_(comm);};

    size_t loops() const;

    static
    message::ref create_param_change_message(const std::string& param_name,
                         loadable_Object_ref parameters,
                         loadable_Object_ref r);

    static 
    message::ref create_force_reinit_message(const std::string& param_name,
                         loadable_Object_ref parameters,
                         loadable_Object_ref r);

    static
    message::ref create_executable_reinit_message(const std::string& param_name,
                          loadable_Object_ref parameters,
                          loadable_Object_ref r);

    static 
    message::ref create_executable_perform_message(const std::string& param_name,
                           loadable_Object_ref parameters,
                           loadable_Object_ref r,
                           const std::vector<int>);

    size_t priority() const { return priority_;};

    bool operator<( const message& r) const { 
    if (priority_ == r.priority_)
        return param_name > r.param_name;
    return priority_ < r.priority_;};    

    const char* name() const { return name_();} 

protected:
    int every;
    std::string param_name;
    loadable_Object_ref receiver;
    size_t priority_;

private:

    message();
    message(const message& );

    virtual const char* name_() const = 0;

    virtual size_t loops_() const = 0;

    virtual void prepare_message_(size_t N, const std::string& filen) = 0;
    virtual void deliver_message_(MPI_Comm, size_t loop_nr) const = 0;
    virtual void close_message_(MPI_Comm) = 0;      
};

inline bool compare_messages_by_priority( message::ref m1, message::ref m2)
{
    return !(m1->operator<(*m2));
}

#endif