C++ snippets

Active object is a good example of wrapping "naked thread". From the caller point of view, it gives asynchronous functionality.
This time I will try to implement active object using boost future library. As in previous example, part 1, client is free to handle some task (let's say processing GUI events), while active object performing heavy duty task in a background. Boost Futures can be understand as one-off events. Client can poll the future to see if the event has occurred. Another important feature of using futures, that future may have data associated with it.
Bellow is C++ code snippet, which implements active object with Future:

#include 
#include 
#include 
#include 
#include 
#include 

class Message
{
    std::string message_; 
    public:
        explicit Message(const std::string& name) : message_(name) {} 
        std::string report() const
        {
            return message_;
        }
            
};

class ActiveObject : boost::noncopyable
{
    public:
        ActiveObject() 
        {
        }

        virtual ~ActiveObject()
        {
            std::cout << "destroying active object" << std::endl;
        }
        
        boost::shared_future getMessageFromRemote(int messageId)
        {
            boost::packaged_task task(boost::bind(&ActiveObject::someMesssage, this, messageId));            
            boost::shared_future res(task.get_future());

            boost::thread(boost::move(task));
            return res;
        }

    private:
        Message someMesssage(int messageId)
        {
            if (messageId == 1) 
                return Message("first");
            else if (messageId == 2)
                return Message("second");
            else
                return Message("empty");
        }
};

int main()
{
    ActiveObject ao;
    
    int id(1);
    boost::shared_future fmessage = ao.getMessageFromRemote(id);
    while (!fmessage.is_ready())
    {
        std::cout << "+";
    }

    Message message = fmessage.get();
    std::cout << message.report() << std::endl;

    return 0;
}