SynchronousQueue.h

Go to the documentation of this file.

/*
 * 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.
 */

#ifndef _DECAF_UTIL_CONCURRENT_SYNCHRONOUSQUEUE_H_
#define _DECAF_UTIL_CONCURRENT_SYNCHRONOUSQUEUE_H_

#include <decaf/util/Config.h>

#include <decaf/util/concurrent/BlockingQueue.h>

#include <vector>

namespace decaf {
namespace util {
namespace concurrent {

    template< typename E >
    class SynchronousQueue : public BlockingQueue<E> {
    private:

        class EmptyIterator : public Iterator<E> {
        public:

            virtual E next() {
                throw NoSuchElementException(
                    __FILE__, __LINE__,
                    "Cannot traverse a Synchronous Queue.");
            }

            virtual bool hasNext() const {
                return false;
            }

            virtual void remove() {
                throw lang::exceptions::IllegalStateException(
                    __FILE__, __LINE__,
                    "No Elements to remove from a Synchronous Queue.");
            }
        };

    private:

        SynchronousQueue(const SynchronousQueue&);
        SynchronousQueue& operator=(const SynchronousQueue&);

    public:

        SynchronousQueue() : BlockingQueue<E>() {}

        virtual ~SynchronousQueue() {}

        virtual void put(const E& value DECAF_UNUSED) {

            //if (o == null) throw new NullPointerException();
            //if (transferer.transfer(o, false, 0) == null) {
            //    Thread.interrupted();
            //    throw new InterruptedException();
            //}
        }

        virtual bool offer(const E& e DECAF_UNUSED, long long timeout DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED) {

            //if (o == null) throw new NullPointerException();
            //if (transferer.transfer(o, true, unit.toNanos(timeout)) != null)
            //    return true;
            //if (!Thread.interrupted())
            //    return false;
            //throw new InterruptedException();

            throw false;
        }

        virtual bool offer(const E& value DECAF_UNUSED) {

            //if (e == null) throw new NullPointerException();
            //return transferer.transfer(e, true, 0) != null;

            return false;
        }

        virtual E take() {
            //Object e = transferer.transfer(null, false, 0);
            //if (e != null)
            //    return (E)e;
            //Thread.interrupted();
            //throw new InterruptedException();

            return E();
        }

        virtual bool poll(E& result DECAF_UNUSED, long long timeout DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED) {

            //Object e = transferer.transfer(null, true, unit.toNanos(timeout));
            //if (e != null || !Thread.interrupted())
            //    return (E)e;
            //throw new InterruptedException();

            return false;
        }

        virtual bool poll(E& result DECAF_UNUSED) {
            return false; // (E)transferer.transfer(null, true, 0);
        }

        virtual bool equals(const Collection<E>& value) const {
            if ((void*) &value == this) {
                return true;
            }

            return false;
        }

        virtual decaf::util::Iterator<E>* iterator() {
            return new EmptyIterator();
        }

        virtual decaf::util::Iterator<E>* iterator() const {
            return new EmptyIterator();
        }

        virtual bool isEmpty() const {
            return true;
        }

        virtual int size() const {
            return 0;
        }

        virtual int remainingCapacity() const {
            return 0;
        }

        virtual void clear() {}

        virtual bool contains(const E& value DECAF_UNUSED) const {
            return false;
        }

        virtual bool containsAll(const Collection<E>& collection) const {
            return collection.isEmpty();
        }

        virtual bool remove(const E& value DECAF_UNUSED) {
            return false;
        }

        virtual bool removeAll(const Collection<E>& collection DECAF_UNUSED) {
            return false;
        }

        virtual bool retainAll(const Collection<E>& collection DECAF_UNUSED) {
            return false;
        }

        virtual bool peek(E& result DECAF_UNUSED) const {
            return false;
        }

        virtual std::vector<E> toArray() const {
            return std::vector<E>();
        }

        virtual int drainTo(Collection<E>& c) {

            if ((void*) &c == this) {
                throw decaf::lang::exceptions::IllegalArgumentException(
                    __FILE__, __LINE__,
                    "Cannot drain a Collection to Itself.");
            }

            int count = 0;
            E element;

            while ((poll(element)) != false) {
                c.add(element);
                ++count;
            }

            return count;
        }

        virtual int drainTo(Collection<E>& c, int maxElements) {

            if ((void*) &c == this) {
                throw decaf::lang::exceptions::IllegalArgumentException(
                    __FILE__, __LINE__,
                    "Cannot drain a Collection to Itself.");
            }

            int count = 0;
            E element;

            while (count < maxElements && (poll(element) != false)) {
                c.add(element);
                ++count;
            }

            return count;
        }

    public:

        using AbstractQueue<E>::remove;

    };

}}}

#endif /* _DECAF_UTIL_CONCURRENT_SYNCHRONOUSQUEUE_H_ */