StringComposer.hpp

#pragma once
#ifndef __H__OCULAR_UTILS_STRING_COMPOSER__H__
#define __H__OCULAR_UTILS_STRING_COMPOSER__H__

#include <string>
#include <sstream>
#include <mutex>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Utils
    {
        class StringComposer
        {
        public:

            StringComposer() 
                : m_IncompleteString(), m_Mutex()
            { 
            
            }

            ~StringComposer() { }

            template<typename T, typename... U>
            std::string compose(T first, U... args)
            {
                std::string result;

                m_Mutex.lock();

                m_IncompleteString.str(std::string());
                m_IncompleteString << first;

                internalCompose(args...);
                result = m_IncompleteString.str();

                m_Mutex.unlock();

                return result;
            }

        protected:

        private:

            template<typename T, typename... U>
            void internalCompose(T first, U... last)
            {
                m_IncompleteString << first;
                internalCompose(last...);
            }

            static void internalCompose()
            {
                // Empty, but required as it is called when
                // there are no more arguments.
            }

            std::stringstream m_IncompleteString;
            std::mutex m_Mutex;
        };
    }
}
#define OCULAR_STRING_COMPOSER Ocular::Utils::StringComposer().compose

//------------------------------------------------------------------------------------------

#endif