/*--------------------------------------------------------------------------*
 *
 *  Microsoft Windows
 *  Copyright (C) Microsoft Corporation, 1992 - 1998.
 *
 *  File:      strtable.inl
 *
 *  Contents:  Inline functions for strtable.h
 *
 *  History:   25-Jun-98 jeffro     Created
 *
 *--------------------------------------------------------------------------*/

#ifndef STRTABLE_INL
#define STRTABLE_INL
#pragma once

#include "macros.h"     // for THROW_ON_FAIL
#include "stgio.h"



/*+-------------------------------------------------------------------------*
 * operator>>
 *
 * Reads a IdentifierRange<T> from a stream.
 *--------------------------------------------------------------------------*/

template<class T>
inline IStream& operator>> (IStream& stm, IdentifierRange<T>& range)
{
    stm >> range.idMin >> range.idMax;

    if (range.idMin > range.idMax)
        _com_issue_error (E_FAIL);

    return (stm);
}


/*+-------------------------------------------------------------------------*
 * operator<<
 *
 * Writes a IdentifierRange<T> to a stream.
 *--------------------------------------------------------------------------*/

template<class T>
inline IStream& operator<< (IStream& stm, const IdentifierRange<T>& range)
{
    return (stm << range.idMin << range.idMax);
}


/*+-------------------------------------------------------------------------*
 * CIdentifierPool<T>::CIdentifierPool
 *
 *
 *--------------------------------------------------------------------------*/

template<class T>
inline CIdentifierPool<T>::CIdentifierPool (T idMin_, T idMax_)
    :   m_idAbsoluteMin   (idMin_),
        m_idAbsoluteMax   (idMax_),
        m_idNextAvailable (idMin_)
{
    ASSERT (m_idAbsoluteMin <= m_idAbsoluteMax);
    m_AvailableIDs.push_front (Range (m_idAbsoluteMin, m_idAbsoluteMax));

    ASSERT (m_StaleIDs.empty());
}

template<class T>
inline CIdentifierPool<T>::CIdentifierPool (IStream& stm)
{
    stm >> *this;
}


/*+-------------------------------------------------------------------------*
 * CIdentifierPool<T>::Reserve
 *
 *
 *--------------------------------------------------------------------------*/

template<class T>
T CIdentifierPool<T>::Reserve ()
{
    /*
     * if no more IDs are available, recycle the stale IDs
     */
    if (m_AvailableIDs.empty())
    {
        m_AvailableIDs.splice (m_AvailableIDs.end(), m_StaleIDs);
        ASSERT (m_StaleIDs.empty());
    }

    /*
     * if still no more IDs are available, throw an exception
     */
    if (m_AvailableIDs.empty())
        throw (pool_exhausted());

    /*
     * get the first ID from the first ID range
     */
    Range& FirstRange = m_AvailableIDs.front();
    T idReserved = FirstRange.idMin;

    /*
     * if we get here, we're going to return an ID, make sure it's the one
     * we though it was going to be
     */
    ASSERT (idReserved == m_idNextAvailable);

    /*
     * if the first ID range is now empty, remove it; otherwise,
     * remove the ID we just reserved from the available range
     */
    if (FirstRange.idMin == FirstRange.idMax)
        m_AvailableIDs.pop_front();
    else
        FirstRange.idMin++;

    /*
     * remember the next available ID
     */
    if (!m_AvailableIDs.empty())
        m_idNextAvailable = m_AvailableIDs.front().idMin;
    else if (!m_StaleIDs.empty())
        m_idNextAvailable = m_StaleIDs.front().idMin;
    else
        m_idNextAvailable = m_idAbsoluteMin;

    return (idReserved);
}


/*+-------------------------------------------------------------------------*
 * CIdentifierPool<T>::Release
 *
 *
 *--------------------------------------------------------------------------*/

template<class T>
bool CIdentifierPool<T>::Release (T idRelease)
{
    /*
     * if the ID to be released falls outside
     * the range managed by this pool, fail
     */
    if ((idRelease < m_idAbsoluteMin) || (idRelease > m_idAbsoluteMax))
    {
        ASSERT (false);
        return (false);
    }

    /*
     * put the released ID in the stale pool
     */
    return (AddToRangeList (m_StaleIDs, idRelease));
}


/*+-------------------------------------------------------------------------*
 * CIdentifierPool<T>::IsValid
 *
 *
 *--------------------------------------------------------------------------*/

template<class T>
bool CIdentifierPool<T>::IsValid () const
{
    if (m_idAbsoluteMin > m_idAbsoluteMax)
        return (false);

    if (!IsRangeListValid (m_AvailableIDs))
        return (false);

    if (!IsRangeListValid (m_StaleIDs))
        return (false);

    return (true);
}


/*+-------------------------------------------------------------------------*
 * CIdentifierPool<T>::IsRangeListValid
 *
 *
 *--------------------------------------------------------------------------*/

template<class T>
bool CIdentifierPool<T>::IsRangeListValid (const RangeList& rl) const
{
    RangeList::const_iterator it;

    for (it = rl.begin(); it != rl.end(); ++it)
    {
        if ((it->idMin < m_idAbsoluteMin) ||
            (it->idMax > m_idAbsoluteMax))
            return (false);
    }

    return (true);
}


/*+-------------------------------------------------------------------------*
 * CIdentifierPool<T>::ScGenerate
 *
 *
 *--------------------------------------------------------------------------*/

template<class T>
SC CIdentifierPool<T>::ScGenerate (const RangeList& rlInUseIDs)
{
    DECLARE_SC (sc, _T("CIdentifierPool<T>::ScGenerate"));
    m_AvailableIDs.clear();
    m_StaleIDs.clear();

    /*
     * Invert the in-use IDs.  We'll then have a collection of all the
     * ID's that are not in use.  Note that not all of these ID's are
     * necessarily "available", since some may be stale.
     */
    RangeList rlNotInUseIDs = rlInUseIDs;
    sc = ScInvertRangeList (rlNotInUseIDs);
    if (sc)
        return (sc);

    /*
     * Find the range containing the next available ID.
     */
    RangeList::iterator it;

    for (it = rlNotInUseIDs.begin(); it != rlNotInUseIDs.end(); ++it)
    {
		/*
		 * if this range contains the next available ID, we've found a hit
		 */
		if ((m_idNextAvailable >= it->idMin) && (m_idNextAvailable <= it->idMax))
		{
			/*
			 * if the next available ID is at the beginning of this range,
			 * things are simple; we can just break out of the loop
			 */
			if (m_idNextAvailable == it->idMin)
				break;

			/*
			 * otherwise, we need to split the current range into two
			 * adjacent ranges so the code below that copies to the
			 * stale and available ranges can work; then we can break out
			 * of the loop
			 */
			Range range (m_idNextAvailable, it->idMax);
			it->idMax = m_idNextAvailable - 1;
			it = rlNotInUseIDs.insert (++it, range);
			break;
		}
    }

    /*
     * confirm that we found one
     */
    ASSERT (it != rlNotInUseIDs.end());

    /*
     * everything before the next available ID that's not it use is stale;
     * everything after  the next available ID that's not in use is available;
     */
    std::copy (rlNotInUseIDs.begin(), it, std::back_inserter(m_StaleIDs));
    std::copy (it, rlNotInUseIDs.end(),   std::back_inserter(m_AvailableIDs));

    return (sc);
}


/*+-------------------------------------------------------------------------*
 * CIdentifierPool<T>::AddToRangeList
 *
 * This adds an identifier to the specified range list.
 *
 * This really should be a member function on a RangeList class, like so:
 *
 *      class RangeList : public std::list<Range>
 *      {
 *      public:
 *          bool Add (const Range& rangeToAdd);
 *          bool Add (T tAdd);
 *      };
 *
 * but compiler bugs prevent it.
 *--------------------------------------------------------------------------*/

template<class T>
bool CIdentifierPool<T>::AddToRangeList (RangeList& rl, T idAdd)
{
    return (AddToRangeList (rl, Range (idAdd, idAdd)));
}

template<class T>
bool CIdentifierPool<T>::AddToRangeList (RangeList& l, const Range& rangeToAdd)
{
    RangeList::iterator it;

    for (it = l.begin(); it != l.end(); ++it)
    {
        Range& rangeT = *it;

        /*
         * the range to add shouldn't overlap the existing range in any way
         */
        if (((rangeToAdd.idMin >= rangeT.idMin) && (rangeToAdd.idMin <= rangeT.idMax)) ||
            ((rangeToAdd.idMax >= rangeT.idMin) && (rangeToAdd.idMax <= rangeT.idMax)))
        {
            ASSERT (false);
            return (false);
        }

        /*
         * If the range to add is immediately to the left of the current
         * range (that is, the upper bound of the range to add is immediately
         * adjacent to the lower bound of the current range), it can be
         * absorbed into the current range and we're done.
         *
         * Note that we don't have to worry about coalescing this range
         * with the preceeding range.  That case would have been covered
         * by the next clause, in the preceeding iteration of this loop.
         */
        if (rangeToAdd.idMax == (rangeT.idMin - 1))
        {
            rangeT.idMin = rangeToAdd.idMin;
            return (true);
        }


        /*
         * If the range to add is immediately to the right of the current
         * range (that is, the lower bound of the range to add is immediately
         * adjacent to the upper bound of the current range), it can be
         * absorbed into the current range and we're done.
         */
        else if (rangeToAdd.idMin == (rangeT.idMax + 1))
        {
            rangeT.idMax = rangeToAdd.idMax;

            /*
             * Now check the next available range (if there is one).
             * If it begins where the current range now ends, then
             * the two ranges can be coalesced into a single range.
             */
            if (++it != l.end())
            {
                Range& rangeNext = *it;
                ASSERT (rangeT.idMax < rangeNext.idMin);

                if (rangeT.idMax == (rangeNext.idMin - 1))
                {
                    rangeT.idMax = rangeNext.idMax;
                    l.erase (it);
                }
            }

            return (true);
        }


        /*
         * If the upper bound of the range to insert is less than the
         * lower bound of the current available range, we need to insert
         * the new range here. The insertion is handled outside the loop.
         */
        else if (rangeToAdd.idMax < rangeT.idMin)
            break;

    }

    /*
     * If we get here, then we need to create a new available range
     * to the left of the current iterator, which will address the
     * end of the list if the ID is greater than the current maximum
     * available ID.
     */
    ASSERT ((it == l.end()) || (rangeToAdd.idMax < (it->idMin - 1)));
    l.insert (it, rangeToAdd);

    return (true);
}


/*+-------------------------------------------------------------------------*
 * CIdentifierPool<T>::ScInvertRangeList
 *
 * Changes rlInvert into a range list containing all elements between
 * m_idAbsoluteMin and m_idAbsoluteMax that were not originally in
 * rlInvert.
 *
 * So, if the range looks like this before inversion:
 *
 *                         +----+----+           +----+----+
 *   m_idAbsoluteMin       |  5 | 10 | --------> | 15 | 20 |    m_idAbsoluteMax
 *                         +----+----+           +----+----+
 *
 * it will look like this after inversion:
 *
 * +-----------------+----+           +----+----+           +----+-----------------+
 * | m_idAbsoluteMin |  4 | --------> | 11 | 14 | --------> | 21 | m_idAbsoluteMax |
 * +-----------------+----+           +----+----+           +----+-----------------+
 *--------------------------------------------------------------------------*/

template<class T>
SC CIdentifierPool<T>::ScInvertRangeList (RangeList& rlInvert) const
{
    DECLARE_SC (sc, _T("CIdentifierPool::ScInvertRangeList"));

    /*
     * if there's nothing in the list to invert, the inverted
     * list will contain a single range spanning min to max
     */
    if (rlInvert.empty())
    {
        rlInvert.push_front (Range (m_idAbsoluteMin, m_idAbsoluteMax));
        return (sc);
    }

    /*
     * determine whether we'll need to add ranges on the front or back,
     * and initialize the ranges we'll add if we will
     */
    Range rFirst;
    bool fAddFirstRange = (rlInvert.front().idMin > m_idAbsoluteMin);
    if (fAddFirstRange)
    {
        rFirst.idMin = m_idAbsoluteMin;
        rFirst.idMax = rlInvert.front().idMin - 1;
    }

    Range rLast;
    bool fAddLastRange = (rlInvert.back().idMax < m_idAbsoluteMax);
    if (fAddLastRange)
    {
        rLast.idMin = rlInvert.back().idMax + 1;
        rLast.idMax = m_idAbsoluteMax;
    }

    /*
     * Change rlInvert to contain ranges that represent the gaps
     * between the ranges it currently contains.  The size of rlInvert
     * will be one less than its original size when this process is
     * complete.
     */
    RangeList::iterator it     =   rlInvert.begin();
    RangeList::iterator itNext = ++rlInvert.begin();

    while (itNext != rlInvert.end())
    {
        /*
         * morph this range into the range representing the gap between
         * this range and the next one
         */
        it->idMin = it->idMax + 1;
        it->idMax = itNext->idMin - 1;

        /*
         * advance the iterators
         */
        it = itNext++;
    }

    /*
     * remove the extraneous node at the end of the list
     */
    rlInvert.pop_back();

    /*
     * append to the beginning and/or end, if necessary
     */
    if (fAddFirstRange)
        rlInvert.push_front (rFirst);

    if (fAddLastRange)
        rlInvert.push_back (rLast);

    return (sc);
}


/*+-------------------------------------------------------------------------*
 * operator>>
 *
 * Reads a CIdentifierPool<T> from a stream
 *--------------------------------------------------------------------------*/

template<class T>
IStream& operator>> (IStream& stm, CIdentifierPool<T>& pool)
{
    /*
     * read the min and max IDs from the stream
     */
    stm >> pool.m_idAbsoluteMin >> pool.m_idAbsoluteMax;

    /*
     * read the available and stale IDs
     */
    stm >> pool.m_AvailableIDs >> pool.m_StaleIDs;

    /*
     * find out how big the stream is
     */
    STATSTG statstg;
    HRESULT hr = stm.Stat (&statstg, STATFLAG_NONAME);
    if (FAILED (hr))
        _com_issue_error (hr);

    /*
     * get our seek position
     */
    ULARGE_INTEGER  uliSeekPos;
    LARGE_INTEGER   liOffset;
    liOffset.QuadPart = 0;
    hr = stm.Seek (liOffset, STREAM_SEEK_CUR, &uliSeekPos);
    if (FAILED (hr))
        _com_issue_error (hr);

    /*
     * Older files won't have saved the next available ID.  If it's there,
     * read it; if not, use a default value for pool.m_idNextAvailable.
     */
    if (statstg.cbSize.QuadPart > uliSeekPos.QuadPart)
    {
        stm >> pool.m_idNextAvailable;
    }
    else
    {
        if (!pool.m_AvailableIDs.empty())
            pool.m_idNextAvailable = pool.m_AvailableIDs.front().idMin;
        else
            pool.m_idNextAvailable = pool.m_idAbsoluteMin;
    }

    /*
     * validate what we read
     */
    if (!pool.IsValid ())
        _com_issue_error (E_FAIL);

    return (stm);
}


/*+-------------------------------------------------------------------------*
 * operator<<
 *
 * Writes a CIdentifierPool<T> to a stream.
 *--------------------------------------------------------------------------*/

template<class T>
IStream& operator<< (IStream& stm, const CIdentifierPool<T>& pool)
{
    /*
     * write the min and max IDs to the stream
     */
    stm << pool.m_idAbsoluteMin << pool.m_idAbsoluteMax;

    /*
     * Write an empty collection of available and stale IDs to keep the
     * stream format the same as previous versions.  Beginning with MMC 2.0,
     * the available and stale IDs will be regenerated from the next available
     * ID and in-use IDs after the string table is read in.  This is done to
     * minimize the data that needs to be saved with the new XML file format.
     */
    CIdentifierPool<T>::RangeList rlEmpty;
    stm << rlEmpty;     // available IDs
    stm << rlEmpty;     // stale IDs

    /*
     * write the next available ID
     */
    stm << pool.m_idNextAvailable;

    return (stm);
}

template<class T>
void CIdentifierPool<T>::Persist(CPersistor &persistor)
{
    persistor.PersistAttribute(XML_ATTR_ID_POOL_ABSOLUTE_MIN, m_idAbsoluteMin);
    persistor.PersistAttribute(XML_ATTR_ID_POOL_ABSOLUTE_MAX, m_idAbsoluteMax);
    persistor.PersistAttribute(XML_ATTR_ID_POOL_NEXT_AVAILABLE, m_idNextAvailable);
}

/*+-------------------------------------------------------------------------*
 * CIdentifierPool<T>::Dump
 *
 *
 *--------------------------------------------------------------------------*/

#ifdef DBG

template<class T>
void CIdentifierPool<T>::DumpRangeList (const RangeList& l) const
{
    int cEntries = 0;

    for (RangeList::const_iterator it = l.begin(); it != l.end(); ++it)
    {
        Trace (tagStringTable, _T("Range %d:min=%d, max=%d"),
               ++cEntries, (int) it->idMin, (int) it->idMax);
    }
}

template<class T>
void CIdentifierPool<T>::Dump () const
{
    Trace (tagStringTable, _T("Next available ID: %d"), m_idNextAvailable);

    Trace (tagStringTable, _T("Available IDs:"));
    DumpRangeList (m_AvailableIDs);

    Trace (tagStringTable, _T("Stale IDs:"));
    DumpRangeList (m_StaleIDs);
}

#endif  // DBG


/*+-------------------------------------------------------------------------*
 * operator>>
 *
 *
 *--------------------------------------------------------------------------*/

inline IStorage& operator>> (IStorage& stg, CComObject<CMasterStringTable>& mst)
{
    return (stg >> static_cast<CMasterStringTable&>(mst));
}


/*+-------------------------------------------------------------------------*
 * operator<<
 *
 *
 *--------------------------------------------------------------------------*/

inline IStorage& operator<< (IStorage& stg, const CComObject<CMasterStringTable>& mst)
{
    return (stg << static_cast<const CMasterStringTable&>(mst));
}


#endif /* STRTABLE_INL */