trunk/ldap/model/src/main/java/org/apache/directory/api/ldap/model/cursor/SetCursor.java - directory-ldap-api - Git at Google

 /*
  * 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.
  */
 package org.apache.directory.api.ldap.model.cursor;


 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Set;

 import org.apache.directory.api.i18n.I18n;
 import org.apache.directory.api.ldap.model.constants.Loggers;
 import org.apache.directory.api.ldap.model.exception.LdapException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;


 /**
  * A simple implementation of a Cursor on a {@link Set}.  Optionally, the
  * Cursor may be limited to a specific range within the list.
  *
  * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
  * @param <E> The element on which this cursor will iterate
  */
 public class SetCursor<E> extends AbstractCursor<E>
 {
     /** A dedicated log for cursors */
     private static final Logger LOG_CURSOR = LoggerFactory.getLogger( Loggers.CURSOR_LOG.getName() );

     /** Speedup for logs */
     private static final boolean IS_DEBUG = LOG_CURSOR.isDebugEnabled();

     /** The inner Set */
     private final E[] set;

     /** The associated comparator */
     private final Comparator<E> comparator;

     /** The current position in the list */
     private int index = -1;

     /** A limit to what we can print */
     private static final int MAX_PRINTED_ELEMENT = 100;


     /**
      * Creates a new SetCursor.
      *
      * As with all Cursors, this SetCursor requires a successful return from
      * advance operations (next() or previous()) to properly return values
      * using the get() operation.
      *
      * @param comparator an optional comparator to use for ordering
      * @param set the Set this StCursor operates on
      */
     @SuppressWarnings("unchecked")
     public SetCursor( Comparator<E> comparator, Set<E> set )
     {
         if ( set == null )
         {
             set = Collections.EMPTY_SET;
         }

         if ( IS_DEBUG )
         {
             LOG_CURSOR.debug( "Creating SetCursor {}", this );
         }

         this.comparator = comparator;
         this.set = ( E[] ) set.toArray();
     }


     /**
      * Creates a new SetCursor
      *
      * As with all Cursors, this SetCursor requires a successful return from
      * advance operations (next() or previous()) to properly return values
      * using the get() operation.
      *
      * @param set the Set this SetCursor operates on
      */
     public SetCursor( Set<E> set )
     {
         this( null, set );
     }


     /**
      * Creates a new SetCursor without any elements.
      */
     @SuppressWarnings("unchecked")
     public SetCursor()
     {
         this( null, Collections.EMPTY_SET );
     }


     /**
      * Creates a new SetCursor without any elements. We also provide
      * a comparator.
      *
      * @param comparator The comparator to use for the <E> elements
      */
     @SuppressWarnings("unchecked")
     public SetCursor( Comparator<E> comparator )
     {
         this( comparator, Collections.EMPTY_SET );
     }


     /**
      * {@inheritDoc}
      */
     public boolean available()
     {
         return ( index >= 0 ) && ( index < set.length );
     }


     /**
      * {@inheritDoc}
      */
     public void before( E element ) throws LdapException, CursorException
     {
         checkNotClosed( "before()" );

         if ( comparator == null )
         {
             throw new IllegalStateException();
         }

         // handle some special cases
         if ( set.length == 0 )
         {
             return;
         }
         else if ( set.length == 1 )
         {
             if ( comparator.compare( element, set[0] ) <= 0 )
             {
                 beforeFirst();
             }
             else
             {
                 afterLast();
             }
         }

         throw new UnsupportedOperationException( I18n.err( I18n.ERR_02008_LIST_MAY_BE_SORTED ) );
     }


     /**
      * {@inheritDoc}
      */
     public void after( E element ) throws LdapException, CursorException
     {
         checkNotClosed( "after()" );

         if ( comparator == null )
         {
             throw new IllegalStateException();
         }

         // handle some special cases
         if ( set.length == 0 )
         {
             return;
         }
         else if ( set.length == 1 )
         {
             if ( comparator.compare( element, set[0] ) >= 0 )
             {
                 afterLast();
             }
             else
             {
                 beforeFirst();
             }
         }

         throw new UnsupportedOperationException( I18n.err( I18n.ERR_02008_LIST_MAY_BE_SORTED ) );
     }


     /**
      * {@inheritDoc}
      */
     public void beforeFirst() throws LdapException, CursorException
     {
         checkNotClosed( "beforeFirst()" );
         this.index = -1;
     }


     /**
      * {@inheritDoc}
      */
     public void afterLast() throws LdapException, CursorException
     {
         checkNotClosed( "afterLast()" );
         this.index = set.length;
     }


     /**
      * {@inheritDoc}
      */
     public boolean first() throws LdapException, CursorException
     {
         checkNotClosed( "first()" );

         if ( set.length > 0 )
         {
             index = 0;

             return true;
         }

         return false;
     }


     /**
      * {@inheritDoc}
      */
     public boolean last() throws LdapException, CursorException
     {
         checkNotClosed( "last()" );

         if ( set.length > 0 )
         {
             index = set.length - 1;

             return true;
         }

         return false;
     }


     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isFirst()
     {
         return ( set.length > 0 ) && ( index == 0 );
     }


     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isLast()
     {
         return ( set.length > 0 ) && ( index == set.length - 1 );
     }


     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isAfterLast()
     {
         return index == set.length;
     }


     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isBeforeFirst()
     {
         return index == -1;
     }


     /**
      * {@inheritDoc}
      */
     public boolean previous() throws LdapException, CursorException
     {
         checkNotClosed( "previous()" );

         // if parked at -1 we cannot go backwards
         if ( index == -1 )
         {
             return false;
         }

         // if the index moved back is still greater than or eq to start then OK
         if ( index - 1 >= 0 )
         {
             index--;

             return true;
         }

         // if the index currently less than or equal to start we need to park it at -1 and return false
         if ( index <= 0 )
         {
             index = -1;

             return false;
         }

         if ( set.length <= 0 )
         {
             index = -1;
         }

         return false;
     }


     /**
      * {@inheritDoc}
      */
     public boolean next() throws LdapException, CursorException
     {
         checkNotClosed( "next()" );

         // if parked at -1 we advance to the start index and return true
         if ( ( set.length > 0 ) && ( index == -1 ) )
         {
             index = 0;

             return true;
         }

         // if the index plus one is less than the end then increment and return true
         if ( ( set.length > 0 ) && ( index + 1 < set.length ) )
         {
             index++;

             return true;
         }

         // if the index plus one is equal to the end then increment and return false
         if ( ( set.length > 0 ) && ( index + 1 == set.length ) )
         {
             index++;

             return false;
         }

         if ( set.length <= 0 )
         {
             index = set.length;
         }

         return false;
     }


     /**
      * {@inheritDoc}
      */
     public E get() throws CursorException
     {
         checkNotClosed( "get()" );

         if ( ( index < 0 ) || ( index >= set.length ) )
         {
             throw new CursorException( I18n.err( I18n.ERR_02009_CURSOR_NOT_POSITIONED ) );
         }

         return set[index];
     }


     /**
      * {@inheritDoc}
      */
     @Override
     public void close()
     {
         if ( IS_DEBUG )
         {
             LOG_CURSOR.debug( "Closing ListCursor {}", this );
         }

         super.close();
     }


     /**
      * {@inheritDoc}
      */
     @Override
     public void close( Exception cause )
     {
         if ( IS_DEBUG )
         {
             LOG_CURSOR.debug( "Closing ListCursor {}", this );
         }

         super.close( cause );
     }


     /**
      * @see Object#toString()
      */
     public String toString( String tabs )
     {
         StringBuilder sb = new StringBuilder();

         sb.append( tabs ).append( "SetCursor :\n" );
         sb.append( tabs ).append( "    Index : " ).append( index ).append( "\n" );

         if ( ( set != null ) && ( set.length > 0 ) )
         {
             sb.append( tabs ).append( "    Size : " ).append( set.length ).append( "\n" );

             // Don't print more than 100 elements...
             int counter = 0;

             for ( E e : set )
             {
                 sb.append( tabs ).append( "    " ).append( e ).append( "\n" );
                 counter++;

                 if ( counter == MAX_PRINTED_ELEMENT )
                 {
                     break;
                 }
             }
         }

         return sb.toString();
     }


     /**
      * @see Object#toString()
      */
     public String toString()
     {
         return toString( "" );
     }
 }
	/*
	* 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.
	*/
	package org.apache.directory.api.ldap.model.cursor;


	import java.util.Collections;
	import java.util.Comparator;
	import java.util.Set;

	import org.apache.directory.api.i18n.I18n;
	import org.apache.directory.api.ldap.model.constants.Loggers;
	import org.apache.directory.api.ldap.model.exception.LdapException;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;


	/**
	* A simple implementation of a Cursor on a {@link Set}. Optionally, the
	* Cursor may be limited to a specific range within the list.
	*
	* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
	* @param <E> The element on which this cursor will iterate
	*/
	public class SetCursor<E> extends AbstractCursor<E>
	{
	/** A dedicated log for cursors */
	private static final Logger LOG_CURSOR = LoggerFactory.getLogger( Loggers.CURSOR_LOG.getName() );

	/** Speedup for logs */
	private static final boolean IS_DEBUG = LOG_CURSOR.isDebugEnabled();

	/** The inner Set */
	private final E[] set;

	/** The associated comparator */
	private final Comparator<E> comparator;

	/** The current position in the list */
	private int index = -1;

	/** A limit to what we can print */
	private static final int MAX_PRINTED_ELEMENT = 100;


	/**
	* Creates a new SetCursor.
	*
	* As with all Cursors, this SetCursor requires a successful return from
	* advance operations (next() or previous()) to properly return values
	* using the get() operation.
	*
	* @param comparator an optional comparator to use for ordering
	* @param set the Set this StCursor operates on
	*/
	@SuppressWarnings("unchecked")
	public SetCursor( Comparator<E> comparator, Set<E> set )
	{
	if ( set == null )
	{
	set = Collections.EMPTY_SET;
	}

	if ( IS_DEBUG )
	{
	LOG_CURSOR.debug( "Creating SetCursor {}", this );
	}

	this.comparator = comparator;
	this.set = ( E[] ) set.toArray();
	}


	/**
	* Creates a new SetCursor
	*
	* As with all Cursors, this SetCursor requires a successful return from
	* advance operations (next() or previous()) to properly return values
	* using the get() operation.
	*
	* @param set the Set this SetCursor operates on
	*/
	public SetCursor( Set<E> set )
	{
	this( null, set );
	}


	/**
	* Creates a new SetCursor without any elements.
	*/
	@SuppressWarnings("unchecked")
	public SetCursor()
	{
	this( null, Collections.EMPTY_SET );
	}


	/**
	* Creates a new SetCursor without any elements. We also provide
	* a comparator.
	*
	* @param comparator The comparator to use for the <E> elements
	*/
	@SuppressWarnings("unchecked")
	public SetCursor( Comparator<E> comparator )
	{
	this( comparator, Collections.EMPTY_SET );
	}


	/**
	* {@inheritDoc}
	*/
	public boolean available()
	{
	return ( index >= 0 ) && ( index < set.length );
	}


	/**
	* {@inheritDoc}
	*/
	public void before( E element ) throws LdapException, CursorException
	{
	checkNotClosed( "before()" );

	if ( comparator == null )
	{
	throw new IllegalStateException();
	}

	// handle some special cases
	if ( set.length == 0 )
	{
	return;
	}
	else if ( set.length == 1 )
	{
	if ( comparator.compare( element, set[0] ) <= 0 )
	{
	beforeFirst();
	}
	else
	{
	afterLast();
	}
	}

	throw new UnsupportedOperationException( I18n.err( I18n.ERR_02008_LIST_MAY_BE_SORTED ) );
	}


	/**
	* {@inheritDoc}
	*/
	public void after( E element ) throws LdapException, CursorException
	{
	checkNotClosed( "after()" );

	if ( comparator == null )
	{
	throw new IllegalStateException();
	}

	// handle some special cases
	if ( set.length == 0 )
	{
	return;
	}
	else if ( set.length == 1 )
	{
	if ( comparator.compare( element, set[0] ) >= 0 )
	{
	afterLast();
	}
	else
	{
	beforeFirst();
	}
	}

	throw new UnsupportedOperationException( I18n.err( I18n.ERR_02008_LIST_MAY_BE_SORTED ) );
	}


	/**
	* {@inheritDoc}
	*/
	public void beforeFirst() throws LdapException, CursorException
	{
	checkNotClosed( "beforeFirst()" );
	this.index = -1;
	}


	/**
	* {@inheritDoc}
	*/
	public void afterLast() throws LdapException, CursorException
	{
	checkNotClosed( "afterLast()" );
	this.index = set.length;
	}


	/**
	* {@inheritDoc}
	*/
	public boolean first() throws LdapException, CursorException
	{
	checkNotClosed( "first()" );

	if ( set.length > 0 )
	{
	index = 0;

	return true;
	}

	return false;
	}


	/**
	* {@inheritDoc}
	*/
	public boolean last() throws LdapException, CursorException
	{
	checkNotClosed( "last()" );

	if ( set.length > 0 )
	{
	index = set.length - 1;

	return true;
	}

	return false;
	}


	/**
	* {@inheritDoc}
	*/
	@Override
	public boolean isFirst()
	{
	return ( set.length > 0 ) && ( index == 0 );
	}


	/**
	* {@inheritDoc}
	*/
	@Override
	public boolean isLast()
	{
	return ( set.length > 0 ) && ( index == set.length - 1 );
	}


	/**
	* {@inheritDoc}
	*/
	@Override
	public boolean isAfterLast()
	{
	return index == set.length;
	}


	/**
	* {@inheritDoc}
	*/
	@Override
	public boolean isBeforeFirst()
	{
	return index == -1;
	}


	/**
	* {@inheritDoc}
	*/
	public boolean previous() throws LdapException, CursorException
	{
	checkNotClosed( "previous()" );

	// if parked at -1 we cannot go backwards
	if ( index == -1 )
	{
	return false;
	}

	// if the index moved back is still greater than or eq to start then OK
	if ( index - 1 >= 0 )
	{
	index--;

	return true;
	}

	// if the index currently less than or equal to start we need to park it at -1 and return false
	if ( index <= 0 )
	{
	index = -1;

	return false;
	}

	if ( set.length <= 0 )
	{
	index = -1;
	}

	return false;
	}


	/**
	* {@inheritDoc}
	*/
	public boolean next() throws LdapException, CursorException
	{
	checkNotClosed( "next()" );

	// if parked at -1 we advance to the start index and return true
	if ( ( set.length > 0 ) && ( index == -1 ) )
	{
	index = 0;

	return true;
	}

	// if the index plus one is less than the end then increment and return true
	if ( ( set.length > 0 ) && ( index + 1 < set.length ) )
	{
	index++;

	return true;
	}

	// if the index plus one is equal to the end then increment and return false
	if ( ( set.length > 0 ) && ( index + 1 == set.length ) )
	{
	index++;

	return false;
	}

	if ( set.length <= 0 )
	{
	index = set.length;
	}

	return false;
	}


	/**
	* {@inheritDoc}
	*/
	public E get() throws CursorException
	{
	checkNotClosed( "get()" );

	if ( ( index < 0 ) \|\| ( index >= set.length ) )
	{
	throw new CursorException( I18n.err( I18n.ERR_02009_CURSOR_NOT_POSITIONED ) );
	}

	return set[index];
	}


	/**
	* {@inheritDoc}
	*/
	@Override
	public void close()
	{
	if ( IS_DEBUG )
	{
	LOG_CURSOR.debug( "Closing ListCursor {}", this );
	}

	super.close();
	}


	/**
	* {@inheritDoc}
	*/
	@Override
	public void close( Exception cause )
	{
	if ( IS_DEBUG )
	{
	LOG_CURSOR.debug( "Closing ListCursor {}", this );
	}

	super.close( cause );
	}


	/**
	* @see Object#toString()
	*/
	public String toString( String tabs )
	{
	StringBuilder sb = new StringBuilder();

	sb.append( tabs ).append( "SetCursor :\n" );
	sb.append( tabs ).append( " Index : " ).append( index ).append( "\n" );

	if ( ( set != null ) && ( set.length > 0 ) )
	{
	sb.append( tabs ).append( " Size : " ).append( set.length ).append( "\n" );

	// Don't print more than 100 elements...
	int counter = 0;

	for ( E e : set )
	{
	sb.append( tabs ).append( " " ).append( e ).append( "\n" );
	counter++;

	if ( counter == MAX_PRINTED_ELEMENT )
	{
	break;
	}
	}
	}

	return sb.toString();
	}


	/**
	* @see Object#toString()
	*/
	public String toString()
	{
	return toString( "" );
	}
	}