~drizzle-trunk/drizzle/development

/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 * 

 *  JSON Library, originally from http://jsoncpp.sourceforge.net/

 *

 *  Copyright (C) 2011 Stewart Smith

 *  All rights reserved.

 *

 *  Redistribution and use in source and binary forms, with or without

 *  modification, are permitted provided that the following conditions are

 *  met:

 *

 *      * Redistributions of source code must retain the above copyright

 *  notice, this list of conditions and the following disclaimer.

 *

 *      * Redistributions in binary form must reproduce the above

 *  copyright notice, this list of conditions and the following disclaimer

 *  in the documentation and/or other materials provided with the

 *  distribution.

 *

 *      * The names of its contributors may not be used to endorse or

 *  promote products derived from this software without specific prior

 *  written permission.

 *

 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 */

#pragma once

// included by json_value.cpp

// everything is within Json namespace

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// class ValueIteratorBase

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

ValueIteratorBase::ValueIteratorBase()

#ifndef JSON_VALUE_USE_INTERNAL_MAP

   : current_()

   , isNull_( true )

{

}

#else

   : isArray_( true )

   , isNull_( true )

{

   iterator_.array_ = ValueInternalArray::IteratorState();

}

#endif

#ifndef JSON_VALUE_USE_INTERNAL_MAP

ValueIteratorBase::ValueIteratorBase( const Value::ObjectValues::iterator &current )

   : current_( current )

   , isNull_( false )

{

}

#else

ValueIteratorBase::ValueIteratorBase( const ValueInternalArray::IteratorState &state )

   : isArray_( true )

{

   iterator_.array_ = state;

}

ValueIteratorBase::ValueIteratorBase( const ValueInternalMap::IteratorState &state )

   : isArray_( false )

{

   iterator_.map_ = state;

}

#endif

Value &

ValueIteratorBase::deref() const

{

#ifndef JSON_VALUE_USE_INTERNAL_MAP

   return current_->second;

#else

   if ( isArray_ )

      return ValueInternalArray::dereference( iterator_.array_ );

   return ValueInternalMap::value( iterator_.map_ );

#endif

}

void 

ValueIteratorBase::increment()

{

#ifndef JSON_VALUE_USE_INTERNAL_MAP

   ++current_;

#else

   if ( isArray_ )

      ValueInternalArray::increment( iterator_.array_ );

   ValueInternalMap::increment( iterator_.map_ );

#endif

}

void 

ValueIteratorBase::decrement()

{

#ifndef JSON_VALUE_USE_INTERNAL_MAP

   --current_;

#else

   if ( isArray_ )

      ValueInternalArray::decrement( iterator_.array_ );

   ValueInternalMap::decrement( iterator_.map_ );

#endif

}

ValueIteratorBase::difference_type 

ValueIteratorBase::computeDistance( const SelfType &other ) const

{

#ifndef JSON_VALUE_USE_INTERNAL_MAP

# ifdef JSON_USE_CPPTL_SMALLMAP

   return current_ - other.current_;

# else

   // Iterator for null value are initialized using the default

   // constructor, which initialize current_ to the default

   // std::map::iterator. As begin() and end() are two instance 

   // of the default std::map::iterator, they can not be compared.

   // To allow this, we handle this comparison specifically.

   if ( isNull_  &&  other.isNull_ )

   {

      return 0;

   }

   // Usage of std::distance is not portable (does not compile with Sun Studio 12 RogueWave STL,

   // which is the one used by default).

   // Using a portable hand-made version for non random iterator instead:

   //   return difference_type( std::distance( current_, other.current_ ) );

   difference_type myDistance = 0;

   for ( Value::ObjectValues::iterator it = current_; it != other.current_; ++it )

   {

      ++myDistance;

   }

   return myDistance;

# endif

#else

   if ( isArray_ )

      return ValueInternalArray::distance( iterator_.array_, other.iterator_.array_ );

   return ValueInternalMap::distance( iterator_.map_, other.iterator_.map_ );

#endif

}

bool 

ValueIteratorBase::isEqual( const SelfType &other ) const

{

#ifndef JSON_VALUE_USE_INTERNAL_MAP

   if ( isNull_ )

   {

      return other.isNull_;

   }

   return current_ == other.current_;

#else

   if ( isArray_ )

      return ValueInternalArray::equals( iterator_.array_, other.iterator_.array_ );

   return ValueInternalMap::equals( iterator_.map_, other.iterator_.map_ );

#endif

}

void 

ValueIteratorBase::copy( const SelfType &other )

{

#ifndef JSON_VALUE_USE_INTERNAL_MAP

   current_ = other.current_;

#else

   if ( isArray_ )

      iterator_.array_ = other.iterator_.array_;

   iterator_.map_ = other.iterator_.map_;

#endif

}

Value 

ValueIteratorBase::key() const

{

#ifndef JSON_VALUE_USE_INTERNAL_MAP

   const Value::CZString czstring = (*current_).first;

   if ( czstring.c_str() )

   {

      if ( czstring.isStaticString() )

         return Value( StaticString( czstring.c_str() ) );

      return Value( czstring.c_str() );

   }

   return Value( czstring.index() );

#else

   if ( isArray_ )

      return Value( ValueInternalArray::indexOf( iterator_.array_ ) );

   bool isStatic;

   const char *memberName = ValueInternalMap::key( iterator_.map_, isStatic );

   if ( isStatic )

      return Value( StaticString( memberName ) );

   return Value( memberName );

#endif

}

UInt 

ValueIteratorBase::index() const

{

#ifndef JSON_VALUE_USE_INTERNAL_MAP

   const Value::CZString czstring = (*current_).first;

   if ( !czstring.c_str() )

      return czstring.index();

   return Value::UInt( -1 );

#else

   if ( isArray_ )

      return Value::UInt( ValueInternalArray::indexOf( iterator_.array_ ) );

   return Value::UInt( -1 );

#endif

}

const char *

ValueIteratorBase::memberName() const

{

#ifndef JSON_VALUE_USE_INTERNAL_MAP

   const char *name = (*current_).first.c_str();

   return name ? name : "";

#else

   if ( !isArray_ )

      return ValueInternalMap::key( iterator_.map_ );

   return "";

#endif

}

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// class ValueConstIterator

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

ValueConstIterator::ValueConstIterator()

{

}

#ifndef JSON_VALUE_USE_INTERNAL_MAP

ValueConstIterator::ValueConstIterator( const Value::ObjectValues::iterator &current )

   : ValueIteratorBase( current )

{

}

#else

ValueConstIterator::ValueConstIterator( const ValueInternalArray::IteratorState &state )

   : ValueIteratorBase( state )

{

}

ValueConstIterator::ValueConstIterator( const ValueInternalMap::IteratorState &state )

   : ValueIteratorBase( state )

{

}

#endif

ValueConstIterator &

ValueConstIterator::operator =( const ValueIteratorBase &other )

{

   copy( other );

   return *this;

}

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// class ValueIterator

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

// //////////////////////////////////////////////////////////////////

ValueIterator::ValueIterator()

{

}

#ifndef JSON_VALUE_USE_INTERNAL_MAP

ValueIterator::ValueIterator( const Value::ObjectValues::iterator &current )

   : ValueIteratorBase( current )

{

}

#else

ValueIterator::ValueIterator( const ValueInternalArray::IteratorState &state )

   : ValueIteratorBase( state )

{

}

ValueIterator::ValueIterator( const ValueInternalMap::IteratorState &state )

   : ValueIteratorBase( state )

{

}

#endif

ValueIterator::ValueIterator( const ValueConstIterator &other )

   : ValueIteratorBase( other )

{

}

ValueIterator::ValueIterator( const ValueIterator &other )

   : ValueIteratorBase( other )

{

}

ValueIterator &

ValueIterator::operator =( const SelfType &other )

{

   copy( other );

   return *this;

}