Collections.h

Go to the documentation of this file.

/*
 * Copyright (c) 2005 Beeyond Software Holding BV
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef _CLASS_BEE_UTIL_COLLECTIONS_H
#define _CLASS_BEE_UTIL_COLLECTIONS_H

#ifdef __cplusplus

#include "beecrypt/c++/lang/Object.h"
using beecrypt::lang::Object;
#include "beecrypt/c++/util/Set.h"
using beecrypt::util::Set;
#include "beecrypt/c++/lang/NullPointerException.h"
using beecrypt::lang::NullPointerException;

namespace beecrypt {
    namespace util {
        class BEECRYPTCXXAPI Collections
        {
        private:
            template<class E> class SynchronizedCollection : public beecrypt::lang::Object, public virtual beecrypt::util::Collection<E>
            {
            private:
                Object* _mutex;
                Collection<E>* _c;

            public:
                SynchronizedCollection(Collection<E>* c, Object* mutex) : _c(c), _mutex(mutex)
                {
                    if (!_mutex)
                        throw NullPointerException();
                }
                virtual ~SynchronizedCollection()
                {
                    delete _c;
                }

                virtual bool add(E* e)
                {
                    bool result = false;
                    synchronized (_mutex)
                    {
                        result = _c->add(e);
                    }
                    return result;
                }
                virtual bool addAll(const Collection<E>& c)
                {
                    bool result = false;
                    synchronized (_mutex)
                    {
                        result = _c->addAll(c);
                    }
                    return result;
                }
                virtual void clear()
                {
                    synchronized (_mutex)
                    {
                        _c->clear();
                    }
                }
                virtual bool contains(const E* e) const
                {
                    bool result = false;
                    synchronized (_mutex)
                    {
                        result = _c->contains(e);
                    }
                    return result;
                }
                virtual bool containsAll(const Collection<E>& c) const
                {
                    bool result = false;
                    synchronized (_mutex)
                    {
                        result = _c->containsAll(c);
                    }
                    return result;
                }
                #if 0
                virtual bool equals(const Object* obj) const throw ()
                {
                }
                #endif
                virtual jint size() const throw ()
                {
                    jint result = 0;
                    synchronized (_mutex)
                    {
                        result = _c->size();
                    }
                    return result;
                }
            };

            template<class E> class SynchronizedSet : public SynchronizedCollection<E>, public virtual beecrypt::util::Set<E>
            {
                virtual ~SynchronizedSet() {}
            };

        public:
            template<class E> static Collection<E>* synchronizedCollection(Collection<E>& c)
            {
                return new SynchronizedCollection<E>(&c, &c);
            }
            template<class E> static Collection<E>* synchronizedCollection(Collection<E>& c, Object& mutex)
            {
                return new SynchronizedCollection<E>(&c, &mutex);
            }

            template<class E> static Set<E>* synchronizedSet(Set<E>& s)
            {
                return new SynchronizedSet<E>(&s, &s);
            }
            template<class E> static Set<E>* synchronizedSet(Set<E>& s, Object& mutex)
            {
                return new SynchronizedSet<E>(&s, &mutex);
            }
        };
    }
}

#endif

#endif

---