AAX_CStateDisplayDelegate.h

Go to the documentation of this file.

/*================================================================================================*/
/*
 *
 *  Copyright (c) 2009 Avid Technology, Inc. 
 *  All rights reserved.
 *  
 *  CONFIDENTIAL: This document contains confidential information.  Do not 
 *  read or examine this document unless you are an Avid Technology employee
 *  or have signed a non-disclosure agreement with Avid Technology which protects
 *  the confidentiality of this document.  DO NOT DISCLOSE ANY INFORMATION 
 *  CONTAINED IN THIS DOCUMENT TO ANY THIRD-PARTY WITHOUT THE PRIOR WRITTEN CONSENT 
 *  OF Avid Technolgy, INC.
 *
 */

/*================================================================================================*/


#ifndef AAX_CSTATEDISPLAYDELEGATE_H
#define AAX_CSTATEDISPLAYDELEGATE_H

#include "AAX_IDisplayDelegate.h"
#include "AAX_CString.h"

#include <vector>
#ifdef WINDOWS_VERSION
#include <algorithm>
#endif



template <typename T>
class AAX_CStateDisplayDelegate : public AAX_IDisplayDelegate<T>
{
public:
    AAX_CStateDisplayDelegate( const char * iStateStrings[], T iMinState = 0 );
    AAX_CStateDisplayDelegate(const AAX_CStateDisplayDelegate& other);

    //Virtual Overrides
    AAX_IDisplayDelegate<T>*    Clone() const;
    bool                        ValueToString(T value, AAX_CString* valueString) const;
    bool                        ValueToString(T value, int32_t maxNumChars, AAX_CString* valueString) const;
    bool                        StringToValue(const AAX_CString& valueString, T* value) const;

    void                        AddShortenedStrings( const char * iStateStrings[], int iLength );

    virtual bool            Compare( const AAX_CString& valueString, const AAX_CString& stateString ) const;

private:
    AAX_CStateDisplayDelegate();        //private contructor to prevent its use externally.

    T                           mMinState;
    std::vector<AAX_CString>    mStateStrings;
    
    struct StringTable
    {
        int                         mStrLength;
        std::vector<AAX_CString>    mStateStrings;
    };
    static bool StringTableSortFunc(struct StringTable i, struct StringTable j)
    {
        return (i.mStrLength < j.mStrLength);
    }

    std::vector<struct StringTable> mShortenedStrings;
};

template <typename T>
AAX_CStateDisplayDelegate<T>::AAX_CStateDisplayDelegate( const char * iStateStrings[], T iMinState /* = 0 */ )
{
    mMinState = iMinState;
    for ( int index = 0; iStateStrings[ index ] != 0; ++index )
        mStateStrings.push_back( AAX_CString( iStateStrings[ index ] ) );
}

template <typename T>
AAX_CStateDisplayDelegate<T>::AAX_CStateDisplayDelegate( const AAX_CStateDisplayDelegate & iOther )
{
    mMinState = iOther.mMinState;

    std::vector<AAX_CString>::const_iterator iter = iOther.mStateStrings.begin();
    for ( ; iter != iOther.mStateStrings.end(); ++iter )
        mStateStrings.push_back( AAX_CString( *iter ) );

    if ( iOther.mShortenedStrings.size() > 0 )
    {
        for ( int i = 0; i < (int)iOther.mShortenedStrings.size(); i++ )
            mShortenedStrings.push_back( iOther.mShortenedStrings.at(i) );
    }
}

template <typename T>
void AAX_CStateDisplayDelegate<T>::AddShortenedStrings( const char * iStateStrings[], int iStrLength )
{
    struct StringTable shortendTable;
    shortendTable.mStrLength = iStrLength;
    for ( int index = 0; iStateStrings[ index ] != 0; ++index )
        shortendTable.mStateStrings.push_back( AAX_CString( iStateStrings[ index ] ) );
    mShortenedStrings.push_back(shortendTable);
    
    // keep structure sorted by str lengths
    std::sort(mShortenedStrings.begin(), mShortenedStrings.end(), AAX_CStateDisplayDelegate::StringTableSortFunc );
}

template <typename T>
AAX_IDisplayDelegate<T>*        AAX_CStateDisplayDelegate<T>::Clone() const
{
    return new AAX_CStateDisplayDelegate(*this);
}

template <typename T>
bool    AAX_CStateDisplayDelegate<T>::ValueToString(T value, AAX_CString* valueString) const
{
    T index = value - mMinState;
    if ( index >= (T) 0 && index < (T) mStateStrings.size() )
    {
        *valueString = mStateStrings[ index ];
        return true;
    }

    return false;
}

template <typename T>
bool    AAX_CStateDisplayDelegate<T>::ValueToString(T value, int32_t maxNumChars, AAX_CString* valueString) const
{
    // if we don't ahve any shortened strings, just return the full length version
    if ( mShortenedStrings.size() == 0 )
        return this->ValueToString(value, valueString);
    
    // iterate through shortened strings from longest to shortest
    // taking the first set that is short enough
    T index = value - mMinState;

    if ( index < (T) 0 || index >= (T) mStateStrings.size() )
        return true;

    // first see if the normal string is short enough
    if ( mStateStrings[ index ].Length() < uint32_t(maxNumChars) )
    {
        *valueString = mStateStrings[ index ];
        return true;
    }
        
    for ( int i = (int)mShortenedStrings.size()-1; i >= 0; i-- )
    {
        struct StringTable shortStrings = mShortenedStrings.at(i);
        if ( shortStrings.mStrLength <= maxNumChars )
        {
            if ( index >= (T) 0 && index < (T) shortStrings.mStateStrings.size() )
            {
                *valueString = shortStrings.mStateStrings[ index ];
                return true;
            }
        }
    }

    // if we can't find one short enough, just use the shortest version we can find
    struct StringTable shortestStrings = mShortenedStrings.at(0);
    if ( index >= (T) 0 && index < (T) shortestStrings.mStateStrings.size() )
    {
        *valueString = shortestStrings.mStateStrings[ index ];
        return true;
    }
    
    return false;
}

template <typename T>
bool    AAX_CStateDisplayDelegate<T>::StringToValue(const AAX_CString& valueString, T* value) const
{
    std::vector<AAX_CString>::const_iterator iter = mStateStrings.begin();
    for ( T index = 0; iter != mStateStrings.end(); ++index, ++iter )
    {
        if (Compare(valueString,*iter))
        {
            *value = index + mMinState;
            return true;
        }
    }
    
    *value = mMinState;
    return false;
}

template <typename T>
bool    AAX_CStateDisplayDelegate<T>::Compare( const AAX_CString& valueString, const AAX_CString& stateString ) const
{
    return valueString==stateString;
}

    



#endif //AAX_CSTATEDISPLAYDELEGATE_H