summaryrefslogtreecommitdiff
path: root/cpp/src
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/src')
-rwxr-xr-xcpp/src/Glacier2/FilterI.cpp1
-rwxr-xr-xcpp/src/Glacier2/FilterI.h223
-rw-r--r--cpp/src/Glacier2/Makefile1
3 files changed, 117 insertions, 108 deletions
diff --git a/cpp/src/Glacier2/FilterI.cpp b/cpp/src/Glacier2/FilterI.cpp
index 644c7917e89..71da951ba48 100755
--- a/cpp/src/Glacier2/FilterI.cpp
+++ b/cpp/src/Glacier2/FilterI.cpp
@@ -8,4 +8,3 @@
// **********************************************************************
#include <Glacier2/FilterI.h>
-#include <list>
diff --git a/cpp/src/Glacier2/FilterI.h b/cpp/src/Glacier2/FilterI.h
index 9462db8eb13..3ed044bd433 100755
--- a/cpp/src/Glacier2/FilterI.h
+++ b/cpp/src/Glacier2/FilterI.h
@@ -9,32 +9,37 @@
#ifndef FILTER_I_H
#define FILTER_I_H
-#include <Ice/Identity.h>
#include <Glacier2/Session.h>
+#include <Ice/Identity.h>
+#include <string>
+#include <vector>
+#include <list>
+
namespace Glacier2
{
-template <class T, class P>
+template <typename T, class P>
class FilterT : public P, public IceUtil::Monitor<IceUtil::Mutex>
{
public:
- FilterT(const T&, const T&, const bool);
+
+ FilterT(const std::vector<T>&, const std::vector<T>&, const bool);
//
// Slice to C++ mapping.
//
- virtual void addAccept(const T&, const Ice::Current&);
- virtual void removeAccept(const T&, const Ice::Current&);
+ virtual void addAccept(const std::vector<T>&, const Ice::Current&);
+ virtual void removeAccept(const std::vector<T>&, const Ice::Current&);
- virtual void setAccept(const T&, const Ice::Current&);
- virtual T getAccept(const Ice::Current&) const;
+ virtual void setAccept(const std::vector<T>&, const Ice::Current&);
+ virtual std::vector<T> getAccept(const Ice::Current&) const;
- virtual void addReject(const T&, const Ice::Current&);
- virtual void removeReject(const T&, const Ice::Current&);
+ virtual void addReject(const std::vector<T>&, const Ice::Current&);
+ virtual void removeReject(const std::vector<T>&, const Ice::Current&);
- virtual void setReject(const T&, const Ice::Current&);
- virtual T getReject(const Ice::Current&) const;
+ virtual void setReject(const std::vector<T>&, const Ice::Current&);
+ virtual std::vector<T> getReject(const Ice::Current&) const;
virtual bool getAcceptOverride(const Ice::Current&) const;
virtual void setAcceptOverride(bool value, const Ice::Current&);
@@ -43,7 +48,7 @@ public:
// Internal functions.
//
bool
- match(const T::value_type& candidate) const
+ match(const T& candidate) const
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
//
@@ -99,16 +104,96 @@ public:
private:
- T _accept;
- T _reject;
+ std::vector<T> _accept;
+ std::vector<T> _reject;
bool _acceptOverride;
- void addImpl(T&, const T&);
- void removeImpl(T&, const T&);
+ void
+ addImpl(std::vector<T>& dest, const std::vector<T>& additions)
+ {
+ //
+ // Sort the filter elements first, erasing duplicates. Then we can
+ // simply use the STL merge algorithm to add to our list of filters.
+ //
+ std::vector<T> newItems(additions);
+ sort(newItems.begin(), newItems.end());
+ newItems.erase(unique(newItems.begin(), newItems.end()), newItems.end());
+
+ IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
+ std::vector<T> merged(dest.size() + newItems.size());
+ merge(newItems.begin(), newItems.end(), dest.begin(), dest.end(), merged.begin());
+ merged.erase(unique(merged.begin(), merged.end()), merged.end());
+ swap(dest, merged);
+ }
+
+ void
+ removeImpl(std::vector<T>& dest, const std::vector<T>& deletions)
+ {
+ //
+ // Our removal algorithm depends on the filter elements to be
+ // removed to be sorted in the same order as our current elements.
+ //
+ std::vector<T> toRemove(dest);
+ sort(toRemove.begin(), toRemove.end());
+ toRemove.erase(unique(toRemove.begin(), toRemove.end()), toRemove.end());
+
+ IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
+
+ //
+ // Our vectors are both sorted, so if we keep track of our first
+ // match between the current set and the set of items to be removed,
+ // we do not need to traverse the whole of the current set each
+ // time. We also use a list of deletions instead of erasing things
+ // itemwise.
+ //
+
+ //
+ // The presence of the 'typename' is a GCC specific workaround. The
+ // iterator types apparently resolve to a 'void' in GCC type
+ // causing compiler errors.
+ //
+ typename std::vector<T>::const_iterator r = toRemove.begin();
+ typename std::vector<T>::iterator mark = dest.begin();
+ typename std::list<typename std::vector<T>::iterator> deleteList;
+
+ while(r != toRemove.end())
+ {
+ typename std::vector<T>::iterator i = mark;
+ while(i != dest.end() && r != toRemove.end())
+ {
+ if(*r == *i)
+ {
+ //
+ // We want this list to be in LIFO order because we are
+ // going to erase things from the tail forward.
+ //
+ deleteList.push_front(i);
+ ++i;
+ ++r;
+ mark = i;
+ }
+ else
+ {
+ ++i;
+ }
+ }
+ if(r == toRemove.end())
+ {
+ break;
+ }
+ ++r;
+ }
+
+ for(typename std::list<typename std::vector<T>::iterator>::const_iterator i = deleteList.begin();
+ i != deleteList.end(); ++i)
+ {
+ dest.erase(*i);
+ }
+ }
};
template<class T, class P>
-FilterT<T, P>::FilterT(const T& accept, const T& reject, const bool acceptOverride):
+FilterT<T, P>::FilterT(const std::vector<T>& accept, const std::vector<T>& reject, const bool acceptOverride):
_accept(accept),
_reject(reject),
_acceptOverride(acceptOverride)
@@ -120,28 +205,28 @@ FilterT<T, P>::FilterT(const T& accept, const T& reject, const bool acceptOverri
}
template<class T, class P> void
-FilterT<T, P>::addAccept(const T& additions, const Ice::Current&)
+FilterT<T, P>::addAccept(const std::vector<T>& additions, const Ice::Current&)
{
addImpl(_accept, additions);
}
template<class T, class P> void
-FilterT<T, P>::removeAccept(const T& deletions, const Ice::Current&)
+FilterT<T, P>::removeAccept(const std::vector<T>& deletions, const Ice::Current&)
{
removeImpl(_accept, deletions);
}
template<class T, class P> void
-FilterT<T, P>::setAccept(const T& filterElements, const Ice::Current&)
+FilterT<T, P>::setAccept(const std::vector<T>& filterElements, const Ice::Current&)
{
- T newItems(filterElements);
+ std::vector<T> newItems(filterElements);
sort(newItems.begin(), newItems.end());
newItems.erase(unique(newItems.begin(), newItems.end()), newItems.end());
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
swap(newItems, _accept);
}
-template<class T, class P> T
+template<class T, class P> std::vector<T>
FilterT<T, P>::getAccept(const Ice::Current&) const
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
@@ -149,28 +234,28 @@ FilterT<T, P>::getAccept(const Ice::Current&) const
}
template<class T, class P> void
-FilterT<T, P>::addReject(const T& additions, const Ice::Current&)
+FilterT<T, P>::addReject(const std::vector<T>& additions, const Ice::Current&)
{
addImpl(_reject, additions);
}
template<class T, class P> void
-FilterT<T, P>::removeReject(const T& deletions, const Ice::Current&)
+FilterT<T, P>::removeReject(const std::vector<T>& deletions, const Ice::Current&)
{
removeImpl(_reject, deletions);
}
template<class T, class P> void
-FilterT<T, P>::setReject(const T& filterElements, const Ice::Current&)
+FilterT<T, P>::setReject(const std::vector<T>& filterElements, const Ice::Current&)
{
- T newItems(filterElements);
+ std::vector<T> newItems(filterElements);
sort(newItems.begin(), newItems.end());
newItems.erase(unique(newItems.begin(), newItems.end()), newItems.end());
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
swap(newItems, _reject);
}
-template<class T, class P> T
+template<class T, class P> std::vector<T>
FilterT<T, P>::getReject(const Ice::Current&) const
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
@@ -191,87 +276,11 @@ FilterT<T, P>::setAcceptOverride(bool value, const Ice::Current&)
_acceptOverride = value;
}
-template<class T, class P> void
-FilterT<T, P>::addImpl(T& dest, const T& additions)
-{
- //
- // Sort the filter elements first, erasing duplicates. Then we can
- // simply use the STL merge algorithm to add to our list of filters.
- //
- T newItems(additions);
- sort(newItems.begin(), newItems.end());
- newItems.erase(unique(newItems.begin(), newItems.end()), newItems.end());
-
- IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
- T merged(dest.size() + newItems.size());
- merge(newItems.begin(), newItems.end(), dest.begin(), dest.end(), merged.begin());
- merged.erase(unique(merged.begin(), merged.end()), merged.end());
- swap(dest, merged);
-}
-
-template<class T, class P> void
-FilterT<T, P>::removeImpl(T& dest, const T& deletions)
-{
- //
- // Our removal algorithm depends on the filter elements to be
- // removed to be sorted in the same order as our current elements.
- //
- T toRemove(dest);
- sort(toRemove.begin(), toRemove.end());
- toRemove.erase(unique(toRemove.begin(), toRemove.end()), toRemove.end());
-
- IceUtil::Monitor<IceUtil::Mutex>::Lock lock(*this);
-
- //
- // Our vectors are both sorted, so if we keep track of our first
- // match between the current set and the set of items to be removed,
- // we do not need to traverse the whole of the current set each
- // time. We also use a list of deletions instead of erasing things
- // itemwise.
- //
- T::const_iterator r = toRemove.begin();
- T::iterator mark = dest.begin();
- list<T::iterator> deleteList;
-
- while(r != toRemove.end())
- {
- T::iterator i = mark;
- while(i != dest.end() && r != toRemove.end())
- {
- if(*r == *i)
- {
- //
- // We want this list to be in LIFO order because we are
- // going to erase things from the tail forward.
- //
- deleteList.push_front(i);
- ++i;
- ++r;
- mark = i;
- }
- else
- {
- ++i;
- }
- }
- if(r == toRemove.end())
- {
- break;
- }
- ++r;
- }
-
- for(list<T::iterator>::const_iterator i = deleteList.begin(); i != deleteList.end(); ++i)
- {
- dest.erase(*i);
- }
-}
-
-typedef FilterT<Ice::IdentitySeq, Glacier2::IdFilter> IdentityFilterI;
-typedef IceUtil::Handle< FilterT<Ice::IdentitySeq, Glacier2::IdFilter> > IdentityFilterIPtr;
+typedef FilterT<Ice::Identity, Glacier2::IdFilter> IdentityFilterI;
+typedef IceUtil::Handle< FilterT<Ice::Identity, Glacier2::IdFilter> > IdentityFilterIPtr;
-typedef FilterT<std::vector<std::string>, Glacier2::StringFilter> StringFilterI;
-typedef IceUtil::Handle< FilterT<std::vector<std::string>, Glacier2::StringFilter> > StringFilterIPtr;
+typedef FilterT<std::string, Glacier2::StringFilter> StringFilterI;
+typedef IceUtil::Handle< FilterT<std::string, Glacier2::StringFilter> > StringFilterIPtr;
};
diff --git a/cpp/src/Glacier2/Makefile b/cpp/src/Glacier2/Makefile
index 84e470bdf97..9847e0d7396 100644
--- a/cpp/src/Glacier2/Makefile
+++ b/cpp/src/Glacier2/Makefile
@@ -34,6 +34,7 @@ ROBJS = Blobject.o \
RequestQueue.o \
RouterI.o \
RoutingTable.o \
+ FilterI.o \
ServerBlobject.o \
SessionRouterI.o
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-04 20:57:49 +0000