FormatableString.h

Go to the documentation of this file.

/*
        Aseba - an event-based framework for distributed robot control
        Copyright (C) 2007--2012:
                Stephane Magnenat <stephane at magnenat dot net>
                (http://stephane.magnenat.net)
                and other contributors, see authors.txt for details
        
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU Lesser General Public License as published
        by the Free Software Foundation, version 3 of the License.
        
        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU Lesser General Public License for more details.
        
        You should have received a copy of the GNU Lesser General Public License
        along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef FORMATABLESTRING_H
#define FORMATABLESTRING_H

#include <string>
#include <sstream>

namespace Aseba
{
        
        template<typename charT>
        class BasicFormatableString : public std::basic_string<charT>
        {
                typedef std::basic_string<charT> S;
                
                private:
                        int argLevel;
                
                        void proceedReplace(const S &replacement);
                        
                public:
                        
                        BasicFormatableString() : S(), argLevel(0) { }
                        BasicFormatableString(const S &s) : S(s), argLevel(0) { }
                        
                        BasicFormatableString &arg(int value, int fieldWidth = 0, int base = 10, charT fillChar = ' ');
                        
                        BasicFormatableString &arg(unsigned value, int fieldWidth = 0, int base = 10, charT fillChar = ' ');
                        
                        BasicFormatableString &arg(float value, int fieldWidth = 0, int precision = 6, charT fillChar = ' ');
                        
                        template <typename T> BasicFormatableString &arg(const T& value)
                        {
                                // transform value into S
                                std::basic_ostringstream<charT> oss;
                                oss << value;
                        
                                proceedReplace(oss.str());
        
                                // return reference to this so that .arg can proceed further
                                return *this;
                        }
                        
                        BasicFormatableString& operator=(const S& str) ;
        };
        
        typedef BasicFormatableString<char> FormatableString;
        typedef BasicFormatableString<wchar_t> WFormatableString;
        
}

#endif // FORMATABLESTRING_H //