tk_stl.h

Go to the documentation of this file.

/*
    Copyright (c) 2006-2018, Alexis Royer, http://alexis.royer.free.fr/CLI

    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.
        * Neither the name of the CLI library project nor the names of its contributors may 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.
*/



#ifndef _CLI_TK_STL_H_
#define _CLI_TK_STL_H_

#include <ctype.h> // toupper, tolower
#include <string.h> // memset

#include <string>
#include <deque>
#include <map>

#include "cli/object.h"


CLI_NS_BEGIN(cli)

    
    CLI_NS_BEGIN(tk)

        
        class String : public cli::Object
        {
        public:
            static const tk::String Concat(
                    const unsigned int UI_MaxLength,    
                    const char* const STR_1,            
                    const char* const STR_2             
                    )
            {
                tk::String str_Result(UI_MaxLength);
                str_Result.Append(STR_1);
                str_Result.Append(STR_2);
                return str_Result;
            }

            static const tk::String Concat(
                    const unsigned int UI_MaxLength,    
                    const char* const STR_1,            
                    const char* const STR_2,            
                    const char* const STR_3             
                    )
            {
                tk::String str_Result(Concat(UI_MaxLength, STR_1, STR_2));
                str_Result.Append(STR_3);
                return str_Result;
            }

            static const tk::String Concat(
                    const unsigned int UI_MaxLength,    
                    const char* const STR_1,            
                    const char* const STR_2,            
                    const char* const STR_3,            
                    const char* const STR_4             
                    )
            {
                tk::String str_Result(Concat(UI_MaxLength, STR_1, STR_2, STR_3));
                str_Result.Append(STR_4);
                return str_Result;
            }

            static const tk::String Concat(
                    const unsigned int UI_MaxLength,    
                    const char* const STR_1,            
                    const char* const STR_2,            
                    const char* const STR_3,            
                    const char* const STR_4,            
                    const char* const STR_5             
                    )
            {
                tk::String str_Result(Concat(UI_MaxLength, STR_1, STR_2, STR_3, STR_4));
                str_Result.Append(STR_5);
                return str_Result;
            }

        private:
            explicit String(void);

        public:
            explicit String(
                    const unsigned int UI_MaxLen    
                    )
              : Object(), m_stlString()
            {
                UnusedParameter(UI_MaxLen); // [contrib: Oleg Smolsky, 2010, based on CLI 2.5]
            }

            explicit String(
                    const unsigned int UI_MaxLen,   
                    const char* const STR_String    
                    )
              : Object(), m_stlString(STR_String)
            {
                UnusedParameter(UI_MaxLen); // [contrib: Oleg Smolsky, 2010, based on CLI 2.5]
            }

            String(
                    const String& TK_String 
                    )
              : Object(), m_stlString((const char* const) TK_String)
            {
            }

            virtual ~String(void)
            {
            }

        public:
            const unsigned int GetLength(void) const
            {
                return (unsigned int) m_stlString.size();
            }

            const bool IsEmpty(void) const
            {
                return (GetLength() <= 0);
            }

            operator const char* const(void) const
            {
                return m_stlString.c_str();
            }

            const char GetChar(
                const unsigned int UI_Pos               
                ) const
            {
                char c_Char = '\0';
                if (UI_Pos < m_stlString.size())
                {
                    c_Char = m_stlString[UI_Pos];
                }
                return c_Char;
            }

            const tk::String SubString(
                    const unsigned int UI_FirstCharacter,   
                    const int I_SubStringLength             
                    ) const
            {
                tk::String str_SubString(0);

                // Determine copy length.
                unsigned int ui_CopyLen = I_SubStringLength;
                if (GetLength() - UI_FirstCharacter < ui_CopyLen)
                    ui_CopyLen = GetLength() - UI_FirstCharacter;

                // Copy.
                if ((UI_FirstCharacter < GetLength()) && (ui_CopyLen > 0))
                {
                    str_SubString.Append(m_stlString.substr(UI_FirstCharacter, ui_CopyLen).c_str());
                }

                return str_SubString;
            }

            const String ToUpper(void) const
            {
                tk::String str_Upper(0);

                const unsigned int ui_StrLen = GetLength() + 1;
                if (char* const pc_Upper = new char[ui_StrLen])
                {
                    memset(pc_Upper, '\0', ui_StrLen);
                    if (const char* const pc_String = (const char*) *this) {
                        for (unsigned int ui=0; ui<ui_StrLen; ui++)
                        {
                            pc_Upper[ui] = toupper(pc_String[ui]);
                        }
                    }
                    str_Upper.Append(pc_Upper);
                    delete [] pc_Upper;
                }

                return str_Upper;
            }

            const String ToLower(void) const
            {
                tk::String str_Lower(0);

                const unsigned int ui_StrLen = GetLength() + 1;
                if (char* const pc_Lower = new char[ui_StrLen])
                {
                    memset(pc_Lower, '\0', ui_StrLen);
                    if (const char* const pc_String = (const char*) *this)
                    {
                        for (unsigned int ui=0; ui<ui_StrLen; ui++)
                        {
                            pc_Lower[ui] = tolower(pc_String[ui]);
                        }
                    }
                    str_Lower.Append(pc_Lower);
                    delete [] pc_Lower;
                }

                return str_Lower;
            }

        public:
            const bool Reset(void)
            {
                m_stlString.erase();
                return true;
            }

            const bool Set(
                    const char* const STR_String    
                    )
            {
                m_stlString = STR_String;
                return true;
            }

            const bool Append(
                    const char* const STR_String    
                    )
            {
                m_stlString += STR_String;
                return true;
            }

            const bool Append(
                    const char C_Character          
                    )
            {
                m_stlString += C_Character;
                return true;
            }

            tk::String& operator=(
                    const tk::String& STR_String    
                    )
            {
                m_stlString = STR_String.m_stlString;
                return *this;
            }

        private:
            std::string m_stlString;
        };


        template <class T> class Queue : public cli::Object
        {
        private:
            explicit Queue(void);

        public:
            explicit Queue(
                    const unsigned int UI_MaxCount  
                    )
              : Object(), m_stlQueue()
            {
                UnusedParameter(UI_MaxCount); // [contrib: Oleg Smolsky, 2010, based on CLI 2.5]
            }

            Queue(
                    const Queue<T>& TK_Queue    
                    )
              : Object(), m_stlQueue(TK_Queue.m_stlQueue)
            {
            }

            virtual ~Queue(void)
            {
            }

        private:
            Queue& operator=(const Queue&);

        public:
            const bool IsEmpty(void) const
            {
                return m_stlQueue.empty();
            }

            const unsigned int GetCount(void) const
            {
                return (unsigned int) m_stlQueue.size();
            }

        public:
            const bool Reset(void)
            {
                m_stlQueue.clear();
                return true;
            }

        public:
            class Iterator : public std::deque<T>::iterator
            {
            private:
                explicit Iterator(void) : std::deque<T>::iterator() {}

            public:
                template <class U>
                Iterator(
                        const U& it     
                        )
                  : std::deque<T>::iterator(it) {}
            };

            Iterator GetIterator(void) const
            {
                return const_cast<std::deque<T>&>(m_stlQueue).begin();
            }

            const bool IsValid(
                    const Iterator& it      
                    ) const
            {
                return (it != m_stlQueue.end());
            }

            const bool MovePrevious(
                    Iterator& it            
                    ) const
            {
                if (it != m_stlQueue.begin())
                {
                    it --;
                    return true;
                }
                else
                {
                    return false;
                }
            }

            const bool MoveNext(
                    Iterator& it            
                    ) const
            {
                it ++;
                return IsValid(it);
            }

            const T& GetAt(
                    const Iterator& it      
                    ) const
            {
                return *it;
            }

            T& GetAt(
                    const Iterator& it      
                    )
            {
                return *it;
            }

            const T Remove(
                    Iterator& it            
                    )
            {
                const T t_Element = *it;
                it = m_stlQueue.erase(it);
                return t_Element;
            }

        public:
            const bool AddHead(
                    const T& T_Element          
                    )
            {
                m_stlQueue.push_front(T_Element);
                return true;
            }

            const bool AddTail(
                    const T& T_Element          
                    )
            {
                m_stlQueue.push_back(T_Element);
                return true;
            }

            const T& GetHead(void) const
            {
                return m_stlQueue.front();
            }

            T& GetHead(void)
            {
                return const_cast<T&>(
                    const_cast<const Queue<T>*>(this)->GetHead()
                );
            }

            const T& GetTail(void) const
            {
                return m_stlQueue.back();
            }

            T& GetTail(void)
            {
                return const_cast<T&>(
                    const_cast<const Queue<T>*>(this)->GetTail()
                );
            }

            const T RemoveHead(void)
            {
                const T t_Element = m_stlQueue.front();
                m_stlQueue.pop_front();
                return t_Element;
            }

            const T RemoveTail(void)
            {
                const T t_Element = m_stlQueue.back();
                m_stlQueue.pop_back();
                return t_Element;
            }

        public:
            const bool Sort(
                    const int (*cmp)(const T&, const T&)    
                    )
            {
                bool b_Result = true;
                if (GetCount() < 2)
                {
                    b_Result = true;
                }
                else
                {
                    // Get a reference element.
                    T t_Ref = RemoveTail();

                    // Dispatch elements in q_1 and q_2.
                    Queue<T> q_1(0), q_2(0);
                    while (! IsEmpty())
                    {
                        T t_Sort = RemoveTail();
                        if (cmp(t_Sort, t_Ref) > 0)
                        {
                            q_1.AddTail(t_Sort);
                        }
                        else
                        {
                            q_2.AddTail(t_Sort);
                        }
                    }

                    // Sort each list q_1 and q_2
                    if (q_1.Sort(cmp) && q_2.Sort(cmp))
                    {
                        // Eventually restore q_1...
                        b_Result = true;
                        for (   Iterator it_1 = q_1.GetIterator();
                                q_1.IsValid(it_1);
                                q_1.MoveNext(it_1))
                        {
                            if (! AddTail(q_1.GetAt(it_1)))
                            {
                                b_Result = false;
                            }
                        }
                        // ... then the reference element...
                        if (! AddTail(t_Ref))
                        {
                            b_Result = false;
                        }
                        // ... and then q_2.
                        for (   Iterator it_2 = q_2.GetIterator();
                                q_2.IsValid(it_2);
                                q_2.MoveNext(it_2))
                        {
                            if (! AddTail(q_2.GetAt(it_2)))
                            {
                                b_Result = false;
                            }
                        }
                    }
                }
                return b_Result;
            }

        private:
            std::deque<T> m_stlQueue;
        };

        template <class K, class T> class Map : public cli::Object
        {
        private:
            explicit Map(void);

        public:
            explicit Map(
                    const unsigned int UI_MaxCount  
                    )
              : Object(), m_stlMap()
            {
            }

            Map(
                    const Map<K,T>& TK_Map      
                    )
              : Object(), m_stlMap(TK_Map.m_stlMap)
            {
            }

            virtual ~Map(void)
            {
            }

        private:
            Map& operator=(const Map&);

        public:
            const bool IsEmpty(void) const
            {
                return m_stlMap.empty();
            }

            const unsigned int GetCount(void) const
            {
                return (unsigned int) m_stlMap.size(); // cast to avoid warnings
            }

        public:
            const bool Reset(void)
            {
                m_stlMap.clear();
                return true;
            }

        public:
            const bool SetAt(
                    const K& K_Key,     
                    const T& T_Value    
                    )
            {
                if (m_stlMap.count(K_Key) > 0)
                {
                    m_stlMap.erase(K_Key);
                }
                m_stlMap.insert(std::make_pair(K_Key, T_Value));
                return true;
            }

            const bool Unset(
                    const K& K_Key      
                    )
            {
                m_stlMap.erase(K_Key);
                return true;
            }

            const bool IsSet(
                    const K& K_Key      
                    ) const
            {
                return (m_stlMap.count(K_Key) > 0);
            }

            const T* const GetAt(
                    const K& K_Key      
                    ) const
            {
                typename std::map<K,T>::const_iterator it = m_stlMap.find(K_Key);
                if (it != m_stlMap.end())
                {
                    return & it->second;
                }
                else
                {
                    return NULL;
                }
            }

        public:
            class Iterator : public std::map<K,T>::iterator
            {
            private:
                explicit Iterator(void) : std::map<K,T>::iterator() {}

            public:
                Iterator(
                        const Iterator& it      
                        )
                  : std::map<K,T>::iterator(it) {}

            private:
                template <class U>
                Iterator& operator=(const U& any) {
                    std::map<K,T>::iterator::operator=(any);
                    return *this;
                }

            private:
                // In order to allow access to privet members for iteration.
                friend class Map;
            };


            Iterator GetIterator(void) const
            {
                Iterator it;
                it = const_cast<std::map<K,T>&>(m_stlMap).begin();
                return it;
            }

            const bool IsValid(
                    const Iterator& it      
                    ) const
            {
                return (it != m_stlMap.end());
            }

            const bool MoveNext(
                    Iterator& it            
                    ) const
            {
                it ++;
                return IsValid(it);
            }

            const K& GetKey(
                    const Iterator& it      
                    ) const
            {
                return it->first;
            }

            const T& GetAt(
                    const Iterator& it      
                    ) const
            {
                return it->second;
            }

            T& GetAt(
                    const Iterator& it      
                    )
            {
                return it->second;
            }

            const T Remove(
                    Iterator& it            
                    )
            {
                const T t_Element = GetAt(it);
                /*it =*/ m_stlMap.erase(it);
                return t_Element;
            }

        private:
            std::map<K,T> m_stlMap;
        };

    CLI_NS_END(tk)

CLI_NS_END(cli)

#endif // _CLI_TK_STL_H_