Mercurial > botc / changeset

--- a/src/format.cpp	Sun Mar 30 22:50:25 2014 +0300
+++ b/src/format.cpp	Fri May 02 20:37:27 2014 +0300
@@ -31,7 +31,8 @@
 #include "format.h"
 #include "lexer.h"
 
-// =============================================================================
+//
+// Throws an error while formatting the string
 //
 static void formatError (String fmtstr, const String errdescribe, int pos)
 {
@@ -46,7 +47,9 @@
 	throw std::logic_error (errmsg.stdString());
 }
 
-// =============================================================================
+//
+// Main formatter algorithm function. Processes @fmtstr with @args and returns
+// the result.
 //
 String formatArgs (const String& fmtstr, const std::vector<String>& args)
 {
@@ -99,9 +102,11 @@
 	return fmt;
 }
 
-// =============================================================================
 //
-void error (String msg)
+// Throws a runtime error with the message @msg. If a lexer is active, its
+// position is printed as well.
+//
+void error (const String& msg)
 {
 	Lexer* lx = Lexer::getCurrentLexer();
 	String fileinfo;

--- a/src/format.h	Sun Mar 30 22:50:25 2014 +0300
+++ b/src/format.h	Fri May 02 20:37:27 2014 +0300
@@ -34,51 +34,51 @@
 
 class FormatArgument
 {
-	public:
-		FormatArgument (const String& a) : m_text (a) {}
-		FormatArgument (char a) : m_text (a) {}
-		FormatArgument (int a) : m_text (String::fromNumber (a)) {}
-		FormatArgument (long a) : m_text (String::fromNumber (a)) {}
-		FormatArgument (const char* a) : m_text (a) {}
+public:
+	FormatArgument (const String& a) : m_text (a) {}
+	FormatArgument (char a) : m_text (a) {}
+	FormatArgument (int a) : m_text (String::fromNumber (a)) {}
+	FormatArgument (long a) : m_text (String::fromNumber (a)) {}
+	FormatArgument (const char* a) : m_text (a) {}
+
+	FormatArgument (void* a)
+	{
+		m_text.sprintf ("%p", a);
+	}
 
-		FormatArgument (void* a)
+	FormatArgument (const void* a)
+	{
+		m_text.sprintf ("%p", a);
+	}
+
+	template<class T> FormatArgument (const List<T>& list)
+	{
+		if (list.isEmpty())
 		{
-			m_text.sprintf ("%p", a);
-		}
-
-		FormatArgument (const void* a)
-		{
-			m_text.sprintf ("%p", a);
+			m_text = "{}";
+			return;
 		}
 
-		template<class T> FormatArgument (const List<T>& list)
-		{
-			if (list.isEmpty())
-			{
-				m_text = "{}";
-				return;
-			}
-
-			m_text = "{ ";
+		m_text = "{ ";
 
-			for (const T& a : list)
-			{
-				if (&a != &list[0])
-					m_text += ", ";
+		for (const T& a : list)
+		{
+			if (&a != &list[0])
+				m_text += ", ";
 
-				m_text += FormatArgument (a).text();
-			}
-
-			m_text += " }";
+			m_text += FormatArgument (a).text();
 		}
 
-		inline const String& text() const
-		{
-			return m_text;
-		}
+		m_text += " }";
+	}
 
-	private:
-		String m_text;
+	inline const String& text() const
+	{
+		return m_text;
+	}
+
+private:
+	String m_text;
 };
 
 #ifndef IN_IDE_PARSER
@@ -98,22 +98,14 @@
 #endif // IN_IDE_PARSER
 
 
-/**
- * Formats the given string with the given args.
- *
- * @param fmtstr Formatter string to process.
- * @param args Args to format with the string.
- * @see format()
- */
+//
+// Formats the given string with the given args.
+//
 String formatArgs (const String& fmtstr, const std::vector<String>& args);
 
-/**
- * Expands the given arguments into a vector of strings.
- *
- * @param data Where to insert the strings.
- * @param arg First argument to process
- * @param rest... Rest of the arguments.
- */
+//
+// Expands the given arguments into a vector of strings.
+//
 template<typename T, typename... RestTypes>
 void expandFormatArguments (std::vector<String>& data, const T& arg, const RestTypes& ... rest)
 {
@@ -121,45 +113,36 @@
 	expandFormatArguments (data, rest...);
 }
 
-/**
- * This is an overload of @c ExpandFormatArguments for end-of-args support.
- */
 static void expandFormatArguments (std::vector<String>& data) __attribute__ ( (unused));
 static void expandFormatArguments (std::vector<String>& data)
 {
 	(void) data;
 }
 
-/**
- * Formats the given formatter string and args and returns the string.
- * This is essentially a modernized sprintf.
- *
- * Args in the format string take the form %n where n is a digit. The argument
- * will be expanded to the nth argument passed. This is essentially Qt's
- * QString::arg() syntax. Note: %0 is invalid.
- *
- * Arguments can be passed a modifier which takes the form of a character
- * just before the digit. Currently supported modifiers are s, d and x.
- *
- * - s: The argument will expand into "s" if it would've not expanded into "1"
- *      otherwise. If it would have expanded into "1" it will expand into an
- *      empty string.
- *
- * - d: The argument expands into the numeric form of the first character of
- *      its previous expansion. Use this to get numeric forms of @c char
- *      arguments.
- *
- * - x: The numeric argument will be represented in hexadecimal notation. This
- *      will work if the argument is a string representing a number. If the
- *      argument did not expand into a number in the first place, 0 is used
- *      (and 0x0 is printed).
- *
- * @param fmtstr Formatter string to process
- * @param raw_args Arguments for the formatter string.
- * @return the formatted string.
- * @see Print
- * @see PrintTo
- */
+//
+// Formats the given formatter string and args and returns the string.
+// This is essentially a modernized sprintf.
+//
+// Args in the format string take the form %n where n is a digit. The argument
+// will be expanded to the nth argument passed. This is essentially Qt's
+// QString::arg() syntax. Note: %0 is invalid.
+//
+// Arguments can be passed a modifier which takes the form of a character
+// just before the digit. Currently supported modifiers are s, d and x.
+//
+// - s: The argument will expand into "s" if it would've not expanded into "1"
+//      otherwise. If it would have expanded into "1" it will expand into an
+//      empty string.
+//
+// - d: The argument expands into the numeric form of the first character of
+//      its previous expansion. Use this to get numeric forms of @c char
+//      arguments.
+//
+// - x: The numeric argument will be represented in hexadecimal notation. This
+//      will work if the argument is a string representing a number. If the
+//      argument did not expand into a number in the first place, 0 is used
+//      and 0x0 is printed.
+//
 template<typename... argtypes>
 String format (const String& fmtstr, const argtypes&... raw_args)
 {
@@ -169,63 +152,67 @@
 	return formatArgs (fmtstr, args);
 }
 
-/**
- * This is an overload of @c format where no arguments are supplied.
- * @return the formatter string as-is.
- */
+//
+// This is an overload of format() where no arguments are supplied.
+// It returns the formatter string as-is.
+//
 static String format (const String& fmtstr) __attribute__ ( (unused));
 static String format (const String& fmtstr)
 {
 	return fmtstr;
 }
 
-/**
- * Processes the given formatter string using @c format and prints it to the
- * specified file pointer.
- *
- * @param fp File pointer to print the formatted string to
- * @param fmtstr Formatter string for @c format
- * @param args Arguments for @c fmtstr
- */
+//
+// Processes the given formatter string using format() and prints it to the
+// specified file pointer.
+//
 template<typename... argtypes>
 void printTo (FILE* fp, const String& fmtstr, const argtypes&... args)
 {
 	fprintf (fp, "%s", format (fmtstr, args...).c_str());
 }
 
-/**
- * Processes the given formatter string using @c format and prints the result to
- * @c stdout.
- *
- * @param fmtstr Formatter string for @c format
- * @param args Arguments for @c fmtstr
- */
+//
+// Processes the given formatter string using format() and appends it to the
+// specified file by name.
+//
+template<typename... argtypes>
+void printTo (const String& filename, const String& fmtstr, const argtypes&... args)
+{
+	FILE* fp = fopen (filename, "a");
+
+	if (fp != null)
+	{
+		fprintf (fp, "%s", format (fmtstr, args...).c_str());
+		fflush (fp);
+		fclose (fp);
+	}
+}
+
+//
+// Processes the given formatter string using format() and prints the result to
+// stdout.
+//
 template<typename... argtypes>
 void print (const String& fmtstr, const argtypes&... args)
 {
 	printTo (stdout, fmtstr, args...);
 }
 
-/**
- * Throws an std::runtime_error with the processed formatted string. The program
- * execution terminates after a call to this function as the exception is first
- * caught in @c main which prints the error to stderr and then exits.
- *
- * @param fmtstr The formatter string of the error.
- * @param args The args to the formatter string.
- * @see Format
- */
+//
+// Throws an std::runtime_error with the processed formatted string. The program
+// execution terminates after a call to this function as the exception is first
+// caught in main() which prints the error to stderr and then exits.
+//
 template<typename... argtypes>
 void error (const String& fmtstr, const argtypes&... args)
 {
 	error (format (fmtstr, args...));
 }
 
-/**
- * An overload of @c Error with no string formatting in between.
- *
- * @param msg The error message.
- */
-void error (String msg);
+//
+// An overload of error() with no string formatting in between.
+//
+void error (const String& msg);
 
 #endif // BOTC_FORMAT_H

--- a/src/lexerScanner.h	Sun Mar 30 22:50:25 2014 +0300
+++ b/src/lexerScanner.h	Fri May 02 20:37:27 2014 +0300
@@ -34,79 +34,79 @@
 
 class LexerScanner
 {
-	public:
-		struct PositionInfo
-		{
-			char*	pos;
-			int		line;
-		};
+public:
+	struct PositionInfo
+	{
+		char*	pos;
+		int		line;
+	};
 
-		// Flags for check_string()
-		enum
-		{
-			FCheckWord = (1 << 0),   // must be followed by whitespace
-			FCheckPeek = (1 << 1),   // don't advance cursor
-		};
+	// Flags for check_string()
+	enum
+	{
+		FCheckWord = (1 << 0),   // must be followed by whitespace
+		FCheckPeek = (1 << 1),   // don't advance cursor
+	};
 
-		static inline bool isSymbolChar (char c, bool allownumbers)
-		{
-			if (allownumbers && (c >= '0' && c <= '9'))
-				return true;
+	static inline bool isSymbolChar (char c, bool allownumbers)
+	{
+		if (allownumbers && (c >= '0' && c <= '9'))
+			return true;
 
-			return (c >= 'a' && c <= 'z') ||
-				   (c >= 'A' && c <= 'Z') ||
-				   (c == '_');
-		}
+		return (c >= 'a' && c <= 'z') ||
+				(c >= 'A' && c <= 'Z') ||
+				(c == '_');
+	}
 
-		LexerScanner (FILE* fp);
-		~LexerScanner();
-		bool getNextToken();
-		String readLine();
+	LexerScanner (FILE* fp);
+	~LexerScanner();
+	bool getNextToken();
+	String readLine();
 
-		inline const String& getTokenText() const
-		{
-			return m_tokenText;
-		}
+	inline const String& getTokenText() const
+	{
+		return m_tokenText;
+	}
 
-		inline int getLine() const
-		{
-			return m_line;
-		}
+	inline int getLine() const
+	{
+		return m_line;
+	}
 
-		inline int getColumn() const
-		{
-			return m_position - m_lineBreakPosition;
-		}
+	inline int getColumn() const
+	{
+		return m_position - m_lineBreakPosition;
+	}
 
-		inline ETokenType getTokenType() const
-		{
-			return m_tokenType;
-		}
+	inline ETokenType getTokenType() const
+	{
+		return m_tokenType;
+	}
 
-		static String getTokenString (ETokenType a);
+	static String getTokenString (ETokenType a);
 
-	private:
-		char*			m_data;
-		char*			m_position;
-		char*			m_lineBreakPosition;
-		String			m_tokenText,
-						m_lastToken;
-		ETokenType		m_tokenType;
-		int				m_line;
+private:
+	char*			m_data;
+	char*			m_position;
+	char*			m_lineBreakPosition;
+	String			m_tokenText,
+					m_lastToken;
+	ETokenType		m_tokenType;
+	int				m_line;
 
-		bool			checkString (const char* c, int flags = 0);
+	bool			checkString (const char* c, int flags = 0);
 
-		// Yields a copy of the current position information.
-		PositionInfo	getPosition() const;
+	// Yields a copy of the current position information.
+	PositionInfo	getPosition() const;
 
-		// Sets the current position based on given data.
-		void			setPosition (const PositionInfo& a);
+	// Sets the current position based on given data.
+	void			setPosition (const PositionInfo& a);
 
-		// Skips one character
-		void			skip();
+	// Skips one character
+	void			skip();
 
-		// Skips many characters
-		void			skip (int chars);
+	// Skips many characters
+	void			skip (int chars);
 };
 
 #endif // BOTC_LEXER_SCANNER_H

--- a/src/list.h	Sun Mar 30 22:50:25 2014 +0300
+++ b/src/list.h	Fri May 02 20:37:27 2014 +0300
@@ -26,8 +26,8 @@
 	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#ifndef BOTC_CONTAINERS_H
-#define BOTC_CONTAINERS_H
+#ifndef BOTC_LIST_H
+#define BOTC_LIST_H
 
 #include <cassert>
 #include <algorithm>
@@ -37,317 +37,303 @@
 template<typename T>
 class List
 {
-	public:
-		using WrappedList				= typename std::deque<T>;
-		using Iterator					= typename WrappedList::iterator;
-		using ConstIterator				= typename WrappedList::const_iterator;
-		using ReverseIterator			= typename WrappedList::reverse_iterator;
-		using ConstReverseIterator		= typename WrappedList::const_reverse_iterator;
-		using ValueType					= T;
-		using Self						= List<T>;
-
-		// =====================================================================
-		//
-		List() {}
-
-		// =====================================================================
-		//
-		List (std::initializer_list<ValueType> vals)
-		{
-			m_data = vals;
-		}
-
-		// =====================================================================
-		//
-		List (const WrappedList& a) :
-			m_data (a) {}
-
-		// =====================================================================
-		//
-		Iterator begin()
-		{
-			return m_data.begin();
-		}
-
-		// =====================================================================
-		//
-		ConstIterator begin() const
-		{
-			return m_data.cbegin();
-		}
-
-		// =====================================================================
-		//
-		Iterator end()
-		{
-			return m_data.end();
-		}
-
-		// =====================================================================
-		//
-		ConstIterator end() const
-		{
-			return m_data.cend();
-		}
-
-		// =====================================================================
-		//
-		ReverseIterator rbegin()
-		{
-			return m_data.rbegin();
-		}
-
-		// =====================================================================
-		//
-		ConstReverseIterator crbegin() const
-		{
-			return m_data.crbegin();
-		}
-
-		// =====================================================================
-		//
-		ReverseIterator rend()
-		{
-			return m_data.rend();
-		}
+public:
+	using Iterator					= typename std::deque<T>::iterator;
+	using ConstIterator				= typename std::deque<T>::const_iterator;
+	using ReverseIterator			= typename std::deque<T>::reverse_iterator;
+	using ConstReverseIterator		= typename std::deque<T>::const_reverse_iterator;
 
-		// =====================================================================
-		//
-		ConstReverseIterator crend() const
-		{
-			return m_data.crend();
-		}
-
-		// =====================================================================
-		//
-		inline void removeAt (int pos)
-		{
-			assert (pos < size());
-			m_data.erase (m_data.begin() + pos);
-		}
-
-		// =====================================================================
-		//
-		ValueType& prepend (const ValueType& value)
-		{
-			m_data.push_front (value);
-			return m_data[0];
-		}
-
-		// =====================================================================
-		//
-		ValueType& append (const ValueType& value)
-		{
-			m_data.push_back (value);
-			return m_data[m_data.size() - 1];
-		}
-
-		// =====================================================================
-		//
-		void merge (const Self& other)
-		{
-			resize (size() + other.size());
-			std::copy (other.begin(), other.end(), begin() + other.size());
-		}
-
-		// =====================================================================
-		//
-		bool pop (T& val)
-		{
-			if (isEmpty())
-				return false;
-
-			val = m_data[size() - 1];
-			m_data.erase (m_data.end() - 1);
-			return true;
-		}
-
-		// =====================================================================
-		//
-		Self& operator<< (const T& value)
-		{
-			append (value);
-			return *this;
-		}
-
-		// =====================================================================
-		//
-		void operator<< (const Self& vals)
-		{
-			merge (vals);
-		}
-
-		// =====================================================================
-		//
-		bool operator>> (T& value)
-		{
-			return pop (value);
-		}
-
-		// =====================================================================
-		//
-		Self reverse() const
-		{
-			Self rev;
+	List();
+	List (const std::deque<T>& a);
+	List (std::initializer_list<T>&& a);
 
-			for (const T & val : *this)
-				val >> rev;
-
-			return rev;
-		}
-
-		// =====================================================================
-		//
-		void clear()
-		{
-			m_data.clear();
-		}
-
-		// =====================================================================
-		//
-		void insert (int pos, const ValueType& value)
-		{
-			m_data.insert (m_data.begin() + pos, value);
-		}
-
-		// =====================================================================
-		//
-		void removeDuplicates()
-		{
-			// Remove duplicate entries. For this to be effective, the vector must be
-			// sorted first.
-			sort();
-			Iterator pos = std::unique (begin(), end());
-			resize (std::distance (begin(), pos));
-		}
-
-		// =====================================================================
-		//
-		int size() const
-		{
-			return m_data.size();
-		}
-
-		// =====================================================================
-		//
-		ValueType& operator[] (int n)
-		{
-			assert (n < size());
-			return m_data[n];
-		}
-
-		// =====================================================================
-		//
-		const ValueType& operator[] (int n) const
-		{
-			assert (n < size());
-			return m_data[n];
-		}
-
-		// =====================================================================
-		//
-		void resize (int size)
-		{
-			m_data.resize (size);
-		}
-
-		// =====================================================================
-		//
-		void sort()
-		{
-			std::sort (begin(), end());
-		}
-
-		// =====================================================================
-		//
-		int find (const ValueType& needle) const
-		{
-			int i = 0;
+	inline T&						append (const T& value);
+	inline Iterator					begin();
+	inline ConstIterator			begin() const;
+	inline void						clear();
+	inline bool						contains (const T& a) const;
+	inline ConstReverseIterator		crbegin() const;
+	inline ConstReverseIterator		crend() const;
+	inline const std::deque<T>&		deque() const;
+	inline Iterator					end();
+	inline ConstIterator			end() const;
+	int								find (const T& needle) const;
+	inline const T&					first() const;
+	inline void						insert (int pos, const T& value);
+	inline bool						isEmpty() const;
+	inline const T&					last() const;
+	void							merge (const List<T>& other);
+	bool							pop (T& val);
+	inline T&						prepend (const T& value);
+	inline ReverseIterator			rbegin();
+	inline void						removeAt (int pos);
+	void							removeDuplicates();
+	void							removeOne (const T& it);
+	inline ReverseIterator			rend();
+	inline void						resize (int size);
+	List<T>							reverse() const;
+	inline int						size() const;
+	inline void						sort();
+	List<T>							splice (int a, int b) const;
 
-			for (const ValueType& hay : *this)
-			{
-				if (hay == needle)
-					return i;
-
-				i++;
-			}
-
-			return -1;
-		}
-
-		// =====================================================================
-		//
-		void removeOne (const ValueType& it)
-		{
-			int idx;
-
-			if ((idx = find (it)) != -1)
-				removeAt (idx);
-		}
-
-		// =====================================================================
-		//
-		inline bool isEmpty() const
-		{
-			return size() == 0;
-		}
-
-		// =====================================================================
-		//
-		Self splice (int a, int b) const
-		{
-			assert (a >= 0 && b >= 0 && a < size() && b < size() && a <= b);
-			Self result;
-
-			for (int i = a; i <= b; ++i)
-				result << operator[] (i);
+	inline List<T>&					operator<< (const T& value);
+	inline List<T>&					operator<< (const List<T>& vals);
+	inline T&						operator[] (int n);
+	inline const T&					operator[] (int n) const;
+	inline List<T>					operator+ (const List<T>& other) const;
 
-			return result;
-		}
-
-		// =====================================================================
-		//
-		inline const WrappedList& deque() const
-		{
-			return m_data;
-		}
-
-		// =====================================================================
-		//
-		inline const ValueType& first() const
-		{
-			return *m_data.begin();
-		}
-
-		// =====================================================================
-		//
-		inline const ValueType& last() const
-		{
-			return *(m_data.end() - 1);
-		}
-
-		// =====================================================================
-		//
-		inline bool contains (const ValueType& a) const
-		{
-			return find (a) != -1;
-		}
-
-		// =====================================================================
-		//
-		Self operator+ (const Self& other) const
-		{
-			Self out (*this);
-			out.merge (other);
-			return out;
-		}
-
-	private:
-		WrappedList m_data;
+private:
+	std::deque<T> _deque;
 };
 
-// =============================================================================
+template<typename T>
+List<T>& operator>> (const T& value, List<T>& haystack);
+
+//
+// --- IMPLEMENTATIONS
 //
+
+template<typename T>
+List<T>::List() {}
+
+template<typename T>
+List<T>::List (const std::deque<T>& other) :
+	_deque (other) {}
+
+template<typename T>
+List<T>::List (std::initializer_list<T>&& a) :
+	_deque (a) {}
+
+template<typename T>
+inline typename List<T>::Iterator List<T>::begin()
+{
+	return _deque.begin();
+}
+
+template<typename T>
+inline typename List<T>::ConstIterator List<T>::begin() const
+{
+	return _deque.cbegin();
+}
+
+template<typename T>
+inline typename List<T>::Iterator List<T>::end()
+{
+	return _deque.end();
+}
+
+template<typename T>
+inline typename List<T>::ConstIterator List<T>::end() const
+{
+	return _deque.cend();
+}
+
+template<typename T>
+inline typename List<T>::ReverseIterator List<T>::rbegin()
+{
+	return _deque.rbegin();
+}
+
+template<typename T>
+inline typename List<T>::ConstReverseIterator List<T>::crbegin() const
+{
+	return _deque.crbegin();
+}
+
+template<typename T>
+inline typename List<T>::ReverseIterator List<T>::rend()
+{
+	return _deque.rend();
+}
+
+template<typename T>
+inline typename List<T>::ConstReverseIterator List<T>::crend() const
+{
+	return _deque.crend();
+}
+
+template<typename T>
+void List<T>::removeAt (int pos)
+{
+	assert (pos < size());
+	_deque.erase (_deque.begin() + pos);
+}
+
+template<typename T>
+inline T& List<T>::prepend (const T& value)
+{
+	_deque.push_front (value);
+	return _deque[0];
+}
+
+template<typename T>
+inline T& List<T>::append (const T& value)
+{
+	_deque.push_back (value);
+	return _deque[_deque.size() - 1];
+}
+
+template<typename T>
+void List<T>::merge (const List<T>& other)
+{
+	resize (size() + other.size());
+	std::copy (other.begin(), other.end(), begin() + other.size());
+}
+
+template<typename T>
+bool List<T>::pop (T& val)
+{
+	if (isEmpty())
+		return false;
+
+	val = _deque[size() - 1];
+	_deque.erase (_deque.end() - 1);
+	return true;
+}
+
+template<typename T>
+inline List<T>& List<T>::operator<< (const T& value)
+{
+	append (value);
+	return *this;
+}
+
+template<typename T>
+inline List<T>& List<T>::operator<< (const List<T>& vals)
+{
+	merge (vals);
+	return *this;
+}
+
+template<typename T>
+List<T> List<T>::reverse() const
+{
+	List<T> rev;
+	std::copy (rbegin(), rend(), rev.begin());
+	return rev;
+}
+
+template<typename T>
+inline void List<T>::clear()
+{
+	_deque.clear();
+}
+
+template<typename T>
+inline void List<T>::insert (int pos, const T& value)
+{
+	_deque.insert (_deque.begin() + pos, value);
+}
+
+template<typename T>
+void List<T>::removeDuplicates()
+{
+	sort();
+	resize (std::distance (begin(), std::unique (begin(), end())));
+}
+
+template<typename T>
+int List<T>::size() const
+{
+	return _deque.size();
+}
+
+template<typename T>
+inline T& List<T>::operator[] (int n)
+{
+	assert (n < size());
+	return _deque[n];
+}
+
+template<typename T>
+inline const T& List<T>::operator[] (int n) const
+{
+	assert (n < size());
+	return _deque[n];
+}
+
+template<typename T>
+inline void List<T>::resize (int size)
+{
+	_deque.resize (size);
+}
+
+template<typename T>
+inline void List<T>::sort()
+{
+	std::sort (begin(), end());
+}
+
+template<typename T>
+int List<T>::find (const T& needle) const
+{
+	auto it = std::find (_deque.cbegin(), _deque.cend(), needle);
+
+	if (it == _deque.end())
+		return -1;
+
+	return it - _deque.cbegin();
+}
+
+template<typename T>
+void List<T>::removeOne (const T& a)
+{
+	auto it = std::find (_deque.begin(), _deque.end(), a);
+
+	if (it != _deque.end())
+		_deque.erase (it);
+}
+
+template<typename T>
+inline bool List<T>::isEmpty() const
+{
+	return size() == 0;
+}
+
+template<typename T>
+List<T> List<T>::splice (int a, int b) const
+{
+	assert (a >= 0 && b >= 0 && a < size() && b < size() && a <= b);
+	List<T> result;
+
+	for (int i = a; i <= b; ++i)
+		result << operator[] (i);
+
+	return result;
+}
+
+template<typename T>
+inline const std::deque<T>& List<T>::deque() const
+{
+	return _deque;
+}
+
+template<typename T>
+inline const T& List<T>::first() const
+{
+	return *_deque.cbegin();
+}
+
+template<typename T>
+inline const T& List<T>::last() const
+{
+	return *(_deque.cend() - 1);
+}
+
+template<typename T>
+inline bool List<T>::contains (const T& a) const
+{
+	return std::find (_deque.cbegin(), _deque.cend(), a) != _deque.end();
+}
+
+template<typename T>
+inline List<T> List<T>::operator+ (const List<T>& other) const
+{
+	List<T> out (*this);
+	out.merge (other);
+	return out;
+}
+
 template<typename T>
 List<T>& operator>> (const T& value, List<T>& haystack)
 {
@@ -355,4 +341,4 @@
 	return haystack;
 }
 
-#endif // BOTC_CONTAINERS_H
+#endif // BOTC_LIST_H

--- a/src/string.h	Sun Mar 30 22:50:25 2014 +0300
+++ b/src/string.h	Fri May 02 20:37:27 2014 +0300
@@ -348,7 +348,7 @@
 		StringList (std::initializer_list<String> vals) :
 			List<String> (vals) {}
 		StringList (const List<String>& a) : List<String> (a.deque()) {}
-		StringList (const WrappedList& a) : List<String> (a) {}
+		StringList (const std::deque<String>& a) : List<String> (a) {}
 
 		String join (const String& delim);
 };