Created SubstitutionField class.

glabels/Merge/SubstitutionField.cpp

@@ -0,0 +1,291 @@
+/*  SubstitutionField.cpp
+ *
+ *  Copyright (C) 2017  Jim Evins <evins@snaught.com>
+ *
+ *  This file is part of gLabels-qt.
+ *
+ *  gLabels-qt is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  gLabels-qt 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with gLabels-qt.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "SubstitutionField.h"
+
+#include <QTextStream>
+
+
+namespace glabels
+{
+
+	merge::SubstitutionField::SubstitutionField( const QString& string )
+	{
+		QStringRef s(&string);
+		parseSubstitutionField( s );
+	}
+
+
+	QString merge::SubstitutionField::evaluate( const merge::Record& record ) const
+	{
+		QString value = mDefaultValue;
+
+		if ( record.contains(mFieldName) )
+		{
+			value = record[mFieldName];
+		}
+
+		if ( mFormatType.isNull() )
+		{
+			return value;
+		}
+		else
+		{
+			return formatValue( value );
+		}
+	}
+
+
+	QString merge::SubstitutionField::fieldName() const
+	{
+		return mFieldName;
+	}
+
+
+	QString merge::SubstitutionField::defaultValue() const
+	{
+		return mDefaultValue;
+	}
+
+
+	QString merge::SubstitutionField::format() const
+	{
+		return mFormat;
+	}
+
+
+	QChar merge::SubstitutionField::formatType() const
+	{
+		return mFormatType;
+	}
+
+
+	QString merge::SubstitutionField::formatValue( const QString& value ) const
+	{
+			switch (mFormatType.unicode())
+			{
+				
+			case 'd':
+			case 'i':
+				return QString::asprintf( mFormat.toStdString().c_str(),
+				                          value.toLongLong(nullptr,0) );
+				break;
+				
+
+			case 'u':
+			case 'x':
+			case 'X':
+			case 'o':
+				return QString::asprintf( mFormat.toStdString().c_str(),
+				                          value.toULongLong(nullptr,0) );
+				break;
+
+			case 'f':
+			case 'F':
+			case 'e':
+			case 'E':
+			case 'g':
+			case 'G':
+				return QString::asprintf( mFormat.toStdString().c_str(),
+				                          value.toDouble() );
+				break;
+
+			case 's':
+				return QString::asprintf( mFormat.toStdString().c_str(),
+				                          value.toStdString().c_str() );
+				break;
+
+			default:
+				// Invalid format
+				return "";
+				break;
+
+			}
+	}
+	
+
+	void merge::SubstitutionField::parseSubstitutionField( QStringRef& s )
+	{
+		if ( s.startsWith( "${" ) )
+		{
+			s = s.mid(2);
+			parseFieldName( s );
+
+			while ( s.size() && s[0] == ':' )
+			{
+				s = s.mid(1);
+				parseModifier( s );
+			}
+
+			if ( s.size() && s[0] == '}' )
+			{
+				s = s.mid(1);
+
+				if ( s.size() )
+				{
+					// Invalid -- extraneous input
+				}
+			}
+			else
+			{
+				// Invalid -- expected '}'
+			}
+
+		}
+		else
+		{
+			// Invalid -- expected '${'
+		}
+	}
+
+
+	void merge::SubstitutionField::parseFieldName( QStringRef& s )
+	{
+		while ( s.size() && (s[0].isDigit() || s[0].isLetter() || s[0] == '_' || s[0] == '-') )
+		{
+			mFieldName.append( s[0] );
+			s = s.mid(1);
+		}
+	}
+
+
+	void merge::SubstitutionField::parseModifier( QStringRef& s )
+	{
+		if ( s.size() && s[0] == '%' )
+		{
+			s = s.mid(1);
+			parseFormatModifier( s );
+		}
+		else if ( s.size() && s[0] == '=' )
+		{
+			s = s.mid(1);
+			parseDefaultValueModifier( s );
+		}
+		else
+		{
+			// Invalid -- unrecognized modifier, expecting one of '%' or '='
+		}
+	}
+
+
+	void merge::SubstitutionField::parseDefaultValueModifier( QStringRef& s )
+	{
+		while ( s.size() && s[0] != ':' && s[0] != '}' )
+		{
+			if ( s[0] == '\\' )
+			{
+				s = s.mid(1); // Skip escape
+				if ( s.size() )
+				{
+					mDefaultValue.append( s[0] );
+					s = s.mid(1);
+				}
+				{
+					// Invalid -- end of string encountered during escape
+				}
+			}
+			else
+			{
+				mDefaultValue.append( s[0] );
+				s = s.mid(1);
+			}
+		}
+	}
+
+
+	void merge::SubstitutionField::parseFormatModifier( QStringRef& s )
+	{
+		mFormat = "%";
+
+		mFormat += parseFormatFlags( s );
+		mFormat += parseFormatWidth( s );
+		
+		if ( s.size() && s[0] == '.' )
+		{
+			s = s.mid(1);
+			mFormat += "." + parseFormatPrecision( s );
+		}
+
+		mFormatType = parseFormatType( s );
+		mFormat += mFormatType;
+	}
+
+
+	QString merge::SubstitutionField::parseFormatFlags( QStringRef& s )
+	{
+		QString flags;
+		
+		while ( s.size() && QString( "-+ 0" ).contains( s[0] ) )
+		{
+			flags.append( s[0] );
+			s = s.mid(1);
+		}
+
+		return flags;
+	}
+
+
+	QString merge::SubstitutionField::parseFormatWidth( QStringRef& s )
+	{
+		return parseNaturalInteger( s );
+	}
+
+
+	QString merge::SubstitutionField::parseFormatPrecision( QStringRef& s )
+	{
+		return parseNaturalInteger( s );
+	}
+
+
+	QChar merge::SubstitutionField::parseFormatType( QStringRef& s )
+	{
+		QChar type = 0;
+
+		if ( s.size() && QString( "diufFeEgGxXos" ).contains( s[0] ) )
+		{
+			type = s[0];
+			s = s.mid(1);
+		}
+
+		return type;
+	}
+
+
+	QString merge::SubstitutionField::parseNaturalInteger( QStringRef& s )
+	{
+		QString value = "";
+		
+		if ( s.size() && s[0] >= '1' && s[0] <= '9' )
+		{
+			value += s[0];
+			s = s.mid(1);
+
+			while ( s.size() && s[0].isDigit() )
+			{
+				value += s[0];
+				s = s.mid(1);
+			}
+		}
+		
+		return value;
+	}
+
+
+} // namespace glabels