00001
00002
00003
#include "pch.h"
00004
#include "channels.h"
00005
00006 NAMESPACE_BEGIN(CryptoPP)
00007 USING_NAMESPACE(std)
00008
00009 #if 0
00010
void MessageSwitch::AddDefaultRoute(
BufferedTransformation &destination, const std::string &channel)
00011 {
00012 m_defaultRoutes.push_back(Route(&destination, channel));
00013 }
00014
00015
void MessageSwitch::AddRoute(
unsigned int begin,
unsigned int end,
BufferedTransformation &destination,
const std::string &channel)
00016 {
00017 RangeRoute route(begin, end, Route(&destination, channel));
00018 RouteList::iterator it = upper_bound(m_routes.begin(), m_routes.end(), route);
00019 m_routes.insert(it, route);
00020 }
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
#endif
00087
00088
class ChannelRouteIterator
00089 {
00090
public:
00091
typedef ChannelSwitch::RouteMap::const_iterator MapIterator;
00092
typedef ChannelSwitch::DefaultRouteList::const_iterator ListIterator;
00093
00094
const std::string m_channel;
00095
bool m_useDefault;
00096 MapIterator m_itMapCurrent, m_itMapEnd;
00097 ListIterator m_itListCurrent, m_itListEnd;
00098
00099 ChannelRouteIterator(
ChannelSwitch &cs,
const std::string &channel)
00100 : m_channel(channel)
00101 {
00102 pair<MapIterator, MapIterator> range = cs.
m_routeMap.equal_range(channel);
00103
if (range.first == range.second)
00104 {
00105 m_useDefault =
true;
00106 m_itListCurrent = cs.
m_defaultRoutes.begin();
00107 m_itListEnd = cs.
m_defaultRoutes.end();
00108 }
00109
else
00110 {
00111 m_useDefault =
false;
00112 m_itMapCurrent = range.first;
00113 m_itMapEnd = range.second;
00114 }
00115 }
00116
00117
bool End()
const
00118
{
00119
return m_useDefault ? m_itListCurrent == m_itListEnd : m_itMapCurrent == m_itMapEnd;
00120 }
00121
00122
void Next()
00123 {
00124
if (m_useDefault)
00125 ++m_itListCurrent;
00126
else
00127 ++m_itMapCurrent;
00128 }
00129
00130
BufferedTransformation & Destination()
00131 {
00132
return m_useDefault ? *m_itListCurrent->first : *m_itMapCurrent->second.first;
00133 }
00134
00135
const std::string & Channel()
00136 {
00137
if (m_useDefault)
00138
return m_itListCurrent->second.get() ? *m_itListCurrent->second.get() : m_channel;
00139
else
00140
return m_itMapCurrent->second.second;
00141 }
00142 };
00143
00144
unsigned int ChannelSwitch::ChannelPut2(
const std::string &channel,
const byte *begin,
unsigned int length,
int messageEnd,
bool blocking)
00145 {
00146
if (!blocking)
00147
throw BlockingInputOnly(
"ChannelSwitch");
00148
00149 ChannelRouteIterator it(*
this, channel);
00150
while (!it.End())
00151 {
00152 it.Destination().ChannelPut2(it.Channel(), begin, length, messageEnd, blocking);
00153 it.Next();
00154 }
00155
return 0;
00156 }
00157
00158
void ChannelSwitch::ChannelInitialize(
const std::string &channel,
const NameValuePairs ¶meters,
int propagation)
00159 {
00160
if (channel.empty())
00161 {
00162 m_routeMap.clear();
00163 m_defaultRoutes.clear();
00164 }
00165
00166 ChannelRouteIterator it(*
this, channel);
00167
while (!it.End())
00168 {
00169 it.Destination().ChannelInitialize(it.Channel(), parameters, propagation);
00170 it.Next();
00171 }
00172 }
00173
00174
bool ChannelSwitch::ChannelFlush(
const std::string &channel,
bool completeFlush,
int propagation,
bool blocking)
00175 {
00176
if (!blocking)
00177
throw BlockingInputOnly(
"ChannelSwitch");
00178
00179 ChannelRouteIterator it(*
this, channel);
00180
while (!it.End())
00181 {
00182 it.Destination().ChannelFlush(it.Channel(), completeFlush, propagation, blocking);
00183 it.Next();
00184 }
00185
return false;
00186 }
00187
00188
bool ChannelSwitch::ChannelMessageSeriesEnd(
const std::string &channel,
int propagation,
bool blocking)
00189 {
00190
if (!blocking)
00191
throw BlockingInputOnly(
"ChannelSwitch");
00192
00193 ChannelRouteIterator it(*
this, channel);
00194
while (!it.End())
00195 {
00196 it.Destination().ChannelMessageSeriesEnd(it.Channel(), propagation);
00197 it.Next();
00198 }
00199
return false;
00200 }
00201
00202 byte * ChannelSwitch::ChannelCreatePutSpace(
const std::string &channel,
unsigned int &size)
00203 {
00204 ChannelRouteIterator it(*
this, channel);
00205
if (!it.End())
00206 {
00207
BufferedTransformation &target = it.Destination();
00208 it.Next();
00209
if (it.End())
00210
return target.
ChannelCreatePutSpace(it.Channel(), size);
00211 }
00212 size = 0;
00213
return NULL;
00214 }
00215
00216
unsigned int ChannelSwitch::ChannelPutModifiable2(
const std::string &channel, byte *inString,
unsigned int length,
int messageEnd,
bool blocking)
00217 {
00218
if (!blocking)
00219
throw BlockingInputOnly(
"ChannelSwitch");
00220
00221 ChannelRouteIterator it(*
this, channel);
00222
if (!it.End())
00223 {
00224
BufferedTransformation &target = it.Destination();
00225
const std::string &targetChannel = it.Channel();
00226 it.Next();
00227
if (it.End())
00228
return target.
ChannelPutModifiable2(targetChannel, inString, length, messageEnd, blocking);
00229 }
00230 ChannelPut2(channel, inString, length, messageEnd, blocking);
00231
return false;
00232 }
00233
00234
void ChannelSwitch::AddDefaultRoute(
BufferedTransformation &destination)
00235 {
00236 m_defaultRoutes.push_back(DefaultRoute(&destination, value_ptr<std::string>(NULL)));
00237 }
00238
00239
void ChannelSwitch::RemoveDefaultRoute(
BufferedTransformation &destination)
00240 {
00241
for (DefaultRouteList::iterator it = m_defaultRoutes.begin(); it != m_defaultRoutes.end(); ++it)
00242
if (it->first == &destination && !it->second.get())
00243 {
00244 m_defaultRoutes.erase(it);
00245
break;
00246 }
00247 }
00248
00249
void ChannelSwitch::AddDefaultRoute(
BufferedTransformation &destination,
const std::string &outChannel)
00250 {
00251 m_defaultRoutes.push_back(DefaultRoute(&destination, outChannel));
00252 }
00253
00254
void ChannelSwitch::RemoveDefaultRoute(
BufferedTransformation &destination,
const std::string &outChannel)
00255 {
00256
for (DefaultRouteList::iterator it = m_defaultRoutes.begin(); it != m_defaultRoutes.end(); ++it)
00257
if (it->first == &destination && (it->second.get() && *it->second == outChannel))
00258 {
00259 m_defaultRoutes.erase(it);
00260
break;
00261 }
00262 }
00263
00264
void ChannelSwitch::AddRoute(
const std::string &inChannel,
BufferedTransformation &destination,
const std::string &outChannel)
00265 {
00266 m_routeMap.insert(RouteMap::value_type(inChannel, Route(&destination, outChannel)));
00267 }
00268
00269
void ChannelSwitch::RemoveRoute(
const std::string &inChannel,
BufferedTransformation &destination,
const std::string &outChannel)
00270 {
00271
typedef ChannelSwitch::RouteMap::iterator MapIterator;
00272 pair<MapIterator, MapIterator> range = m_routeMap.equal_range(inChannel);
00273
00274
for (MapIterator it = range.first; it != range.second; ++it)
00275
if (it->second.first == &destination && it->second.second == outChannel)
00276 {
00277 m_routeMap.erase(it);
00278
break;
00279 }
00280 }
00281
00282 NAMESPACE_END