/**************************************************************
 * 
 * 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 _INDEX_HXX
#define _INDEX_HXX

#include <limits.h>
#include <tools/solar.h>
#include <tools/rtti.hxx>				// for RTTI of SwIndexReg
#include <tools/string.hxx>				// for xub_StrLen
#include <swdllapi.h>

#define INVALID_INDEX STRING_NOTFOUND

// Maximale Anzahl von Indizies im IndexArray (zum Abtesten auf Ueberlaeufe)
class SwIndex;
class SwIndexReg;
struct SwPosition;

#ifndef DBG_UTIL
#define INLINE inline
#else
#define INLINE
#endif

class SW_DLLPUBLIC SwIndex
{
	friend class SwIndexReg;

#ifdef DBG_UTIL
	static int nSerial;
	int MySerial;
#endif

	xub_StrLen	nIndex;
	SwIndexReg*	pArray;
	SwIndex *pNext, *pPrev;

	SwIndex& ChgValue( const SwIndex& rIdx, xub_StrLen nNewValue );
	void Remove();					// Ausketten

public:
    explicit SwIndex(SwIndexReg *const pReg, xub_StrLen const nIdx = 0);
	SwIndex( const SwIndex & );
	SwIndex( const SwIndex &, short nDiff );
	~SwIndex() { Remove(); }

    INLINE xub_StrLen operator++();
    INLINE xub_StrLen operator--();
#ifndef CFRONT
    INLINE xub_StrLen operator++(int);
    INLINE xub_StrLen operator--(int);
#endif

    INLINE xub_StrLen operator+=( xub_StrLen );
    INLINE xub_StrLen operator-=( xub_StrLen );
    INLINE xub_StrLen operator+=( const SwIndex& );
    INLINE xub_StrLen operator-=( const SwIndex& );

    INLINE sal_Bool operator<( const SwIndex& ) const;
    INLINE sal_Bool operator<=( const SwIndex& ) const;
    INLINE sal_Bool operator>( const SwIndex& ) const;
    INLINE sal_Bool operator>=( const SwIndex& ) const;
	sal_Bool operator==( const SwIndex& rSwIndex ) const
	{ return (nIndex == rSwIndex.nIndex) &&  (pArray == rSwIndex.pArray); }

	sal_Bool operator!=( const SwIndex& rSwIndex ) const
	{ return (nIndex != rSwIndex.nIndex) ||  (pArray != rSwIndex.pArray); }

	sal_Bool operator<( xub_StrLen nWert ) const 	{ return nIndex <  nWert; }
	sal_Bool operator<=( xub_StrLen nWert ) const   { return nIndex <= nWert; }
	sal_Bool operator>( xub_StrLen nWert ) const    { return nIndex >  nWert; }
	sal_Bool operator>=( xub_StrLen nWert ) const   { return nIndex >= nWert; }
	sal_Bool operator==( xub_StrLen nWert ) const   { return nIndex == nWert; }
	sal_Bool operator!=( xub_StrLen nWert ) const   { return nIndex != nWert; }

    INLINE SwIndex& operator=( xub_StrLen );
	SwIndex& operator=( const SwIndex & );

	// gebe den Wert vom Index als xub_StrLen zurueck
	xub_StrLen GetIndex() const	{ return nIndex; }

	// ermoeglicht Zuweisungen ohne Erzeugen eines temporaeren
	// Objektes
	SwIndex &Assign(SwIndexReg *,xub_StrLen);

		// Herausgabe des Pointers auf das IndexArray,
		// (fuers RTTI am SwIndexReg)
	const SwIndexReg* GetIdxReg() const { return pArray; }
};

#undef INLINE

class SwIndexReg
{
	friend class SwIndex;
    friend bool lcl_PosOk(const SwPosition & aPos);

    const SwIndex *pFirst, *pLast, *pMiddle;

	// ein globales Array, in das Indizies verschoben werden, die mal
	// temporaer "ausgelagert" werden muessen; oder die zum Zeitpunkt des
	// anlegens kein gueltiges Array kennen (SwPaM/SwPosition!)
	friend void _InitCore();
	friend void _FinitCore();
	static SwIndexReg* pEmptyIndexArray;

protected:
    virtual void Update( SwIndex const & rPos, const xub_StrLen nChangeLen,
                 const bool bNegative = false, const bool bDelete = false );

	void ChkArr();

	sal_Bool HasAnyIndex() const { return 0 != pFirst; }

public:
	SwIndexReg();
    virtual ~SwIndexReg();

	// rtti, abgeleitete moegens gleichtun oder nicht. Wenn sie es gleichtun
	// kann ueber das SwIndexReg typsicher gecastet werden.
	TYPEINFO();

    void MoveTo( SwIndexReg& rArr );
};

#ifndef DBG_UTIL

inline xub_StrLen SwIndex::operator++()
{
    return ChgValue( *this, nIndex+1 ).nIndex;
}
inline xub_StrLen SwIndex::operator--()
{
    return ChgValue( *this, nIndex-1 ).nIndex;
}
#ifndef CFRONT
inline xub_StrLen SwIndex::operator++(int)
{
    xub_StrLen nOldIndex = nIndex;
    ChgValue( *this, nIndex+1 );
    return nOldIndex;
}
inline xub_StrLen SwIndex::operator--(int)
{
    xub_StrLen nOldIndex = nIndex;
    ChgValue( *this, nIndex-1 );
    return nOldIndex;
}
#endif

inline xub_StrLen SwIndex::operator+=( xub_StrLen nWert )
{
    return ChgValue( *this, nIndex + nWert ).nIndex;
}
inline xub_StrLen SwIndex::operator-=( xub_StrLen nWert )
{
    return ChgValue( *this, nIndex - nWert ).nIndex;
}
inline xub_StrLen SwIndex::operator+=( const  SwIndex& rIndex )
{
    return ChgValue( *this, nIndex + rIndex.nIndex ).nIndex;
}
inline xub_StrLen SwIndex::operator-=( const SwIndex& rIndex )
{
    return ChgValue( *this, nIndex - rIndex.nIndex ).nIndex;
}

inline sal_Bool SwIndex::operator<( const SwIndex& rIndex ) const
{
    return nIndex < rIndex.nIndex;
}
inline sal_Bool SwIndex::operator<=( const SwIndex& rIndex ) const
{
    return nIndex <= rIndex.nIndex;
}
inline sal_Bool SwIndex::operator>( const SwIndex& rIndex ) const
{
    return nIndex > rIndex.nIndex;
}
inline sal_Bool SwIndex::operator>=( const SwIndex& rIndex ) const
{
    return nIndex >= rIndex.nIndex;
}
inline SwIndex& SwIndex::operator=( xub_StrLen nWert )
{
    if( nIndex != nWert )
        ChgValue( *this, nWert );
    return *this;
}

#endif // PRODUCT

#endif