AAX_CStateDisplayDelegate.h

Go to the documentation of this file.

/*================================================================================================*/
/*
 *
 *  Copyright 2014-2017, 2019, 2023 Avid Technology, Inc.
 *  All rights reserved.
 *  
 *  CONFIDENTIAL: this document contains confidential information of Avid. Do
 *  not disclose to any third party. Use of the information contained in this
 *  document is subject to an Avid SDK license.
 *
 */
 
/*================================================================================================*/
 
 
#ifndef AAX_CSTATEDISPLAYDELEGATE_H
#define AAX_CSTATEDISPLAYDELEGATE_H
 
#include "AAX_IDisplayDelegate.h"
#include "AAX_CString.h"
 
#include <vector>
#if defined(WINDOWS_VERSION) || defined(LINUX_VERSION)
#include <algorithm>
#endif
 
 
 
template <typename T>
class AAX_CStateDisplayDelegate : public AAX_IDisplayDelegate<T>
{
public:
    explicit AAX_CStateDisplayDelegate( const char * iStateStrings[], T iMinState = 0 );
    
    explicit AAX_CStateDisplayDelegate( int32_t inNumStates, const char * iStateStrings[], T iMinState = 0 );
    
    explicit AAX_CStateDisplayDelegate( const std::vector<AAX_IString*>& iStateStrings, T iMinState = 0 );
    
    AAX_CStateDisplayDelegate(const AAX_CStateDisplayDelegate& other);
 
    //Virtual Overrides
    AAX_IDisplayDelegate<T>*    Clone() const AAX_OVERRIDE;
    bool                        ValueToString(T value, AAX_CString* valueString) const AAX_OVERRIDE;
    bool                        ValueToString(T value, int32_t maxNumChars, AAX_CString* valueString) const AAX_OVERRIDE;
    bool                        StringToValue(const AAX_CString& valueString, T* value) const AAX_OVERRIDE;
    
    //AAX_CStateDisplayDelegate
    void                        AddShortenedStrings( const char * iStateStrings[], int iLength );
    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( int32_t inNumStates, const char * iStateStrings[], T iMinState /* = 0 */ )
{
    mMinState = iMinState;
    for ( int index = 0; (index < inNumStates) && (iStateStrings[ index ] != 0); ++index )
        mStateStrings.push_back( AAX_CString( iStateStrings[ index ] ) );
}
 
template <typename T>
AAX_CStateDisplayDelegate<T>::AAX_CStateDisplayDelegate( const std::vector<AAX_IString*>& iStateStrings, T iMinState /* = 0 */ )
{
    mMinState = iMinState;
    for ( std::vector<AAX_IString*>::const_iterator iter = iStateStrings.begin(); iter != iStateStrings.end(); ++iter )
    {
        if (*iter)
        {
            mStateStrings.push_back( *(*iter) );
        }
    }
}
 
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