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() {}

        virtual ~SynchronousQueue() {}

        virtual void put( const E& value ) {

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

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

            //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 ) {

            //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, long long timeout, const TimeUnit& unit ) {

            //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 ) {
            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;
        }

    };

}}}

#endif /* _DECAF_UTIL_CONCURRENT_SYNCHRONOUSQUEUE_H_ */