summaryrefslogtreecommitdiff
path: root/cpp/include/qpid/messaging/Message.h
blob: 5cd978f2a26ddcc8c711312346776a0722763db0 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#ifndef QPID_MESSAGING_MESSAGE_H
#define QPID_MESSAGING_MESSAGE_H

/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 */
#include "qpid/messaging/ImportExport.h"

#include "qpid/messaging/Duration.h"
#include "qpid/types/Exception.h"
#include "qpid/types/Variant.h"

#include <string>

namespace qpid {
namespace messaging {

class Address;
class Codec;
struct MessageImpl;

/**   \ingroup messaging 
 * Representation of a message.
 */
class QPID_MESSAGING_CLASS_EXTERN Message
{
  public:
    QPID_MESSAGING_EXTERN Message(const std::string& bytes = std::string());
    QPID_MESSAGING_EXTERN Message(const char*, size_t);
    QPID_MESSAGING_EXTERN Message(const Message&);
    QPID_MESSAGING_EXTERN ~Message();

    QPID_MESSAGING_EXTERN Message& operator=(const Message&);

    QPID_MESSAGING_EXTERN void setReplyTo(const Address&);
    QPID_MESSAGING_EXTERN const Address& getReplyTo() const;

    QPID_MESSAGING_EXTERN void setSubject(const std::string&);
    QPID_MESSAGING_EXTERN const std::string& getSubject() const;

    QPID_MESSAGING_EXTERN void setContentType(const std::string&);
    QPID_MESSAGING_EXTERN const std::string& getContentType() const;

    QPID_MESSAGING_EXTERN void setMessageId(const std::string&);
    QPID_MESSAGING_EXTERN const std::string& getMessageId() const;

    QPID_MESSAGING_EXTERN void setUserId(const std::string&);
    QPID_MESSAGING_EXTERN const std::string& getUserId() const;

    QPID_MESSAGING_EXTERN void setCorrelationId(const std::string&);
    QPID_MESSAGING_EXTERN const std::string& getCorrelationId() const;

    QPID_MESSAGING_EXTERN void setPriority(uint8_t);
    QPID_MESSAGING_EXTERN uint8_t getPriority() const;

    /**
     * Set the time to live for this message in milliseconds.
     */
    QPID_MESSAGING_EXTERN void setTtl(Duration ttl);
    /**
     *Get the time to live for this message in milliseconds.
     */
    QPID_MESSAGING_EXTERN Duration getTtl() const;

    QPID_MESSAGING_EXTERN void setDurable(bool durable);
    QPID_MESSAGING_EXTERN bool getDurable() const;

    QPID_MESSAGING_EXTERN bool getRedelivered() const;
    QPID_MESSAGING_EXTERN void setRedelivered(bool);

    QPID_MESSAGING_EXTERN const qpid::types::Variant::Map& getProperties() const;
    QPID_MESSAGING_EXTERN qpid::types::Variant::Map& getProperties();

    QPID_MESSAGING_EXTERN void setContent(const std::string&);
    /**
     * Note that chars are copied.
     */
    QPID_MESSAGING_EXTERN void setContent(const char* chars, size_t count);

    /** Get the content as a std::string */
    QPID_MESSAGING_EXTERN std::string getContent() const;
    /** Get a const pointer to the start of the content data. */
    QPID_MESSAGING_EXTERN const char* getContentPtr() const;
    /** Get the size of content in bytes. */
    QPID_MESSAGING_EXTERN size_t getContentSize() const;

    QPID_MESSAGING_EXTERN void setProperty(const std::string&, const qpid::types::Variant&);
  private:
    MessageImpl* impl;
    friend struct MessageImplAccess;
};

struct QPID_MESSAGING_CLASS_EXTERN EncodingException : qpid::types::Exception
{
    QPID_MESSAGING_EXTERN EncodingException(const std::string& msg);
};

/**
 * Decodes message content into a Variant::Map.
 * 
 * @param message the message whose content should be decoded
 * @param map the map into which the message contents will be decoded
 * @param encoding if specified, the encoding to use - this overrides
 * any encoding specified by the content-type of the message
 * @exception EncodingException
 */
QPID_MESSAGING_EXTERN void decode(const Message& message,
                                  qpid::types::Variant::Map& map,
                                  const std::string& encoding = std::string());
/**
 * Decodes message content into a Variant::List.
 * 
 * @param message the message whose content should be decoded
 * @param list the list into which the message contents will be decoded
 * @param encoding if specified, the encoding to use - this overrides
 * any encoding specified by the content-type of the message
 * @exception EncodingException
 */
QPID_MESSAGING_EXTERN void decode(const Message& message,
                                  qpid::types::Variant::List& list,
                                  const std::string& encoding = std::string());
/**
 * Encodes a Variant::Map into a message.
 * 
 * @param map the map to be encoded
 * @param message the message whose content should be set to the encoded map
 * @param encoding if specified, the encoding to use - this overrides
 * any encoding specified by the content-type of the message
 * @exception EncodingException
 */
QPID_MESSAGING_EXTERN void encode(const qpid::types::Variant::Map& map,
                                  Message& message,
                                  const std::string& encoding = std::string());
/**
 * Encodes a Variant::List into a message.
 * 
 * @param list the list to be encoded
 * @param message the message whose content should be set to the encoded list
 * @param encoding if specified, the encoding to use - this overrides
 * any encoding specified by the content-type of the message
 * @exception EncodingException
 */
QPID_MESSAGING_EXTERN void encode(const qpid::types::Variant::List& list,
                                  Message& message,
                                  const std::string& encoding = std::string());

}} // namespace qpid::messaging

#endif  /*!QPID_MESSAGING_MESSAGE_H*/