message.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later OR BSD-3-Clause
/***************************************************************************
 *   Copyright (C) 2007,2009,2010 by Rick L. Vinyard, Jr.                  *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the dbus-cxx library.                            *
 ***************************************************************************/
#include <stdint.h>
#include <dbus-cxx/error.h>
#include <dbus-cxx/messageappenditerator.h>
#include <dbus-cxx/messageiterator.h>
#include <memory>
#include <string>
#include "enums.h"
 
#include <dbus-cxx/variant.h>
 
#ifndef DBUSCXX_MESSAGE_H
#define DBUSCXX_MESSAGE_H
 
#define DBUSCXX_MESSAGE_NO_REPLY_EXPECTED               0x01
#define DBUSCXX_MESSAGE_NO_AUTO_START_FLAG              0x02
// This is set in CallMessage only.
#define DBUSCXX_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION 0x04
 
namespace DBus {
class ReturnMessage;
 
class Message {
protected:
 
    Message();
 
public:
 
    virtual ~Message();
 
    bool operator == ( const Message& other );
 
    bool is_valid() const;
 
    void invalidate();
 
    operator bool() const;
 
    uint32_t serial() const;
 
    virtual MessageType type() const = 0;
 
    void set_auto_start( bool auto_start );
 
    bool auto_start();
 
    bool set_destination( const std::string& s );
 
    std::string destination() const;
 
    std::string sender() const;
 
    Signature signature() const;
 
    template <typename T>
    MessageIterator operator>>( T& value ) const {
        MessageIterator iter = this->begin();
        iter >> value;
        return iter;
    }
 
    template <typename T>
    MessageAppendIterator operator<<( const T& value ) {
        MessageAppendIterator aiter( *this );
        aiter << value;
        return aiter;
    }
 
    MessageIterator begin() const;
 
    MessageIterator end() const;
 
    MessageAppendIterator append();
 
    bool serialize_to_vector( std::vector<uint8_t>* vec, uint32_t serial ) const;
 
    Variant header_field( MessageHeaderFields field ) const;
 
    uint8_t flags() const;
 
    Variant set_header_field( MessageHeaderFields field, Variant value );
 
    Endianess endianess() const;
 
    const std::vector<int>& filedescriptors() const;
 
    static std::shared_ptr<Message> create_from_data( uint8_t* data, uint32_t data_len, std::vector<int> fds = std::vector<int>() );
 
protected:
 
    void append_signature( std::string toappend );
 
    void clear_sig_and_data();
 
    void set_flags( uint8_t flags );
 
private:
    std::vector<uint8_t>* body();
    const std::vector<uint8_t>* body() const;
    void add_filedescriptor( int fd );
    uint32_t filedescriptors_size() const;
    int filedescriptor_at_location( int location ) const;
 
private:
    class priv_data;
 
    DBUS_CXX_PROPAGATE_CONST( std::unique_ptr<priv_data> ) m_priv;
 
    friend class MessageAppendIterator;
    friend class MessageIterator;
    friend std::ostream& operator<<( std::ostream& os, const DBus::Message* msg );
 
};
 
 
template <typename T>
inline
DBus::MessageIterator operator>>( std::shared_ptr<const DBus::Message> ptr, T& value ) {
    if( !ptr ) { throw DBus::ErrorInvalidSharedPtr(); }
 
    return ( *ptr ) >> value;
}
 
template <typename T>
inline
DBus::MessageAppendIterator operator<<( std::shared_ptr<DBus::Message> ptr, const T& value ) {
    if( !ptr ) { throw DBus::ErrorInvalidSharedPtr(); }
 
    return ( *ptr ) << value;
}
 
}
 
#endif