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
|
// **********************************************************************
//
// Copyright (c) 2002
// ZeroC, Inc.
// Billerica, MA, USA
//
// All Rights Reserved.
//
// Ice is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License version 2 as published by
// the Free Software Foundation.
//
// **********************************************************************
#ifndef SUBSCRIBER_H
#define SUBSCRIBER_H
#include <IceUtil/Mutex.h>
#include <Ice/Current.h> // For Ice::Context
#include <Ice/Identity.h>
#include <vector>
namespace IceStorm
{
//
// Forward declarations.
//
class TraceLevels;
typedef IceUtil::Handle<TraceLevels> TraceLevelsPtr;
//
// Note that at present this requires to copy the event which isn't
// nice. If this indeed becomes a bottleneck then either the event can
// carry a reference to the blob, context & op (while event itself
// isn't copied), or the op, blob & context can be passed along as
// arguments (or do copy on write, or some such trick).
//
struct Event
{
bool forwarded;
int cost;
std::string op;
Ice::OperationMode mode;
std::vector< Ice::Byte> data;
Ice::Context context;
};
//
// Subscriber interface.
//
class Subscriber : public virtual IceUtil::Shared
{
public:
Subscriber(const TraceLevelsPtr& traceLevels, const Ice::Identity&);
~Subscriber();
virtual bool persistent() const = 0;
//
// Return true if the Subscriber is not active, false otherwise.
//
bool inactive() const;
//
// Retrieve true if the Subscriber is in the error state, false
// otherwise.
//
bool error() const;
//
// Retrieve the identity of the Subscriber.
//
Ice::Identity id() const;
//
// Unsubscribe. Mark the state as Unsubscribed.
//
virtual void unsubscribe() = 0;
//
// Unsubscribe. Mark the state as Replaced.
//
virtual void replace() = 0;
//
// Publish the given event. Mark the state as Error in the event of
// a problem.
//
virtual void publish(const Event&) = 0;
protected:
// Immutable
TraceLevelsPtr _traceLevels;
//
// Subscriber state.
//
enum State
{
//
// The Subscriber is active.
//
StateActive,
//
// The Subscriber encountered an error during event
// transmission.
//
StateError,
//
// The Subscriber has been unsubscribed.
//
StateUnsubscribed,
//
// The Subscriber has been replaced.
//
StateReplaced
};
IceUtil::Mutex _stateMutex;
State _state;
private:
//
// This id is the full id of the subscriber for a particular topic.
//
// Immutable.
//
Ice::Identity _id;
};
typedef IceUtil::Handle<Subscriber> SubscriberPtr;
} // End namespace IceStorm
#endif
|
