Corrected other misspelt 'a' words.

Foundation/include/Poco/Clock.h

@@ -30,7 +30,7 @@ class Foundation_API Clock
 	/// A Clock stores a monotonic* clock value
 	/// with (theoretical) microseconds resolution.
 	/// Clocks can be compared with each other
-	/// and simple arithmetics are supported.
+	/// and simple arithmetic is supported.
 	///
 	/// [*] Note that Clock values are only monotonic if
 	/// the operating system provides a monotonic clock.

Foundation/include/Poco/Dynamic/Var.h

@@ -271,16 +271,16 @@ public:
 
 	template <typename T> 
 	Var& operator += (const T& other)
-		/// Addition asignment operator for addition/assignment of POD to Var.
+		/// Addition assignment operator for addition/assignment of POD to Var.
 	{
 		return *this = convert<T>() + other;
 	}
 
 	Var& operator += (const Var& other);
-		/// Addition asignment operator overload for Var
+		/// Addition assignment operator overload for Var
 
 	Var& operator += (const char* other);
-		/// Addition asignment operator overload for const char*
+		/// Addition assignment operator overload for const char*
 
 	template <typename T> 
 	const Var operator - (const T& other) const
@@ -294,13 +294,13 @@ public:
 
 	template <typename T> 
 	Var& operator -= (const T& other)
-		/// Subtraction asignment operator
+		/// Subtraction assignment operator
 	{
 		return *this = convert<T>() - other;
 	}
 
 	Var& operator -= (const Var& other);
-		/// Subtraction asignment operator overload for Var
+		/// Subtraction assignment operator overload for Var
 
 	template <typename T> 
 	const Var operator * (const T& other) const
@@ -314,13 +314,13 @@ public:
 
 	template <typename T> 
 	Var& operator *= (const T& other)
-		/// Multiplication asignment operator
+		/// Multiplication assignment operator
 	{
 		return *this = convert<T>() * other;
 	}
 
 	Var& operator *= (const Var& other);
-		/// Multiplication asignment operator overload for Var
+		/// Multiplication assignment operator overload for Var
 
 	template <typename T> 
 	const Var operator / (const T& other) const
@@ -334,13 +334,13 @@ public:
 
 	template <typename T> 
 	Var& operator /= (const T& other)
-		/// Division asignment operator
+		/// Division assignment operator
 	{
 		return *this = convert<T>() / other;
 	}
 
 	Var& operator /= (const Var& other);
-		/// Division asignment operator specialization for Var
+		/// Division assignment operator specialization for Var
 
 	template <typename T> 
 	bool operator == (const T& other) const
@@ -922,28 +922,28 @@ inline char operator / (const char& other, const Var& da)
 
 
 inline char operator += (char& other, const Var& da)
-	/// Addition asignment operator for adding Var to char
+	/// Addition assignment operator for adding Var to char
 {
 	return other += da.convert<char>();
 }
 
 
 inline char operator -= (char& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from char
+	/// Subtraction assignment operator for subtracting Var from char
 {
 	return other -= da.convert<char>();
 }
 
 
 inline char operator *= (char& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with char
+	/// Multiplication assignment operator for multiplying Var with char
 {
 	return other *= da.convert<char>();
 }
 
 
 inline char operator /= (char& other, const Var& da)
-	/// Division asignment operator for dividing Var with char
+	/// Division assignment operator for dividing Var with char
 {
 	return other /= da.convert<char>();
 }
@@ -1026,28 +1026,28 @@ inline Poco::Int8 operator / (const Poco::Int8& other, const Var& da)
 
 
 inline Poco::Int8 operator += (Poco::Int8& other, const Var& da)
-	/// Addition asignment operator for adding Var to Poco::Int8
+	/// Addition assignment operator for adding Var to Poco::Int8
 {
 	return other += da.convert<Poco::Int8>();
 }
 
 
 inline Poco::Int8 operator -= (Poco::Int8& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from Poco::Int8
+	/// Subtraction assignment operator for subtracting Var from Poco::Int8
 {
 	return other -= da.convert<Poco::Int8>();
 }
 
 
 inline Poco::Int8 operator *= (Poco::Int8& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with Poco::Int8
+	/// Multiplication assignment operator for multiplying Var with Poco::Int8
 {
 	return other *= da.convert<Poco::Int8>();
 }
 
 
 inline Poco::Int8 operator /= (Poco::Int8& other, const Var& da)
-	/// Division asignment operator for dividing Var with Poco::Int8
+	/// Division assignment operator for dividing Var with Poco::Int8
 {
 	return other /= da.convert<Poco::Int8>();
 }
@@ -1130,28 +1130,28 @@ inline Poco::UInt8 operator / (const Poco::UInt8& other, const Var& da)
 
 
 inline Poco::UInt8 operator += (Poco::UInt8& other, const Var& da)
-	/// Addition asignment operator for adding Var to Poco::UInt8
+	/// Addition assignment operator for adding Var to Poco::UInt8
 {
 	return other += da.convert<Poco::UInt8>();
 }
 
 
 inline Poco::UInt8 operator -= (Poco::UInt8& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from Poco::UInt8
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt8
 {
 	return other -= da.convert<Poco::UInt8>();
 }
 
 
 inline Poco::UInt8 operator *= (Poco::UInt8& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with Poco::UInt8
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt8
 {
 	return other *= da.convert<Poco::UInt8>();
 }
 
 
 inline Poco::UInt8 operator /= (Poco::UInt8& other, const Var& da)
-	/// Division asignment operator for dividing Var with Poco::UInt8
+	/// Division assignment operator for dividing Var with Poco::UInt8
 {
 	return other /= da.convert<Poco::UInt8>();
 }
@@ -1234,28 +1234,28 @@ inline Poco::Int16 operator / (const Poco::Int16& other, const Var& da)
 
 
 inline Poco::Int16 operator += (Poco::Int16& other, const Var& da)
-	/// Addition asignment operator for adding Var to Poco::Int16
+	/// Addition assignment operator for adding Var to Poco::Int16
 {
 	return other += da.convert<Poco::Int16>();
 }
 
 
 inline Poco::Int16 operator -= (Poco::Int16& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from Poco::Int16
+	/// Subtraction assignment operator for subtracting Var from Poco::Int16
 {
 	return other -= da.convert<Poco::Int16>();
 }
 
 
 inline Poco::Int16 operator *= (Poco::Int16& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with Poco::Int16
+	/// Multiplication assignment operator for multiplying Var with Poco::Int16
 {
 	return other *= da.convert<Poco::Int16>();
 }
 
 
 inline Poco::Int16 operator /= (Poco::Int16& other, const Var& da)
-	/// Division asignment operator for dividing Var with Poco::Int16
+	/// Division assignment operator for dividing Var with Poco::Int16
 {
 	return other /= da.convert<Poco::Int16>();
 }
@@ -1338,28 +1338,28 @@ inline Poco::UInt16 operator / (const Poco::UInt16& other, const Var& da)
 
 
 inline Poco::UInt16 operator += (Poco::UInt16& other, const Var& da)
-	/// Addition asignment operator for adding Var to Poco::UInt16
+	/// Addition assignment operator for adding Var to Poco::UInt16
 {
 	return other += da.convert<Poco::UInt16>();
 }
 
 
 inline Poco::UInt16 operator -= (Poco::UInt16& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from Poco::UInt16
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt16
 {
 	return other -= da.convert<Poco::UInt16>();
 }
 
 
 inline Poco::UInt16 operator *= (Poco::UInt16& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with Poco::UInt16
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt16
 {
 	return other *= da.convert<Poco::UInt16>();
 }
 
 
 inline Poco::UInt16 operator /= (Poco::UInt16& other, const Var& da)
-	/// Division asignment operator for dividing Var with Poco::UInt16
+	/// Division assignment operator for dividing Var with Poco::UInt16
 {
 	return other /= da.convert<Poco::UInt16>();
 }
@@ -1442,28 +1442,28 @@ inline Poco::Int32 operator / (const Poco::Int32& other, const Var& da)
 
 
 inline Poco::Int32 operator += (Poco::Int32& other, const Var& da)
-	/// Addition asignment operator for adding Var to Poco::Int32
+	/// Addition assignment operator for adding Var to Poco::Int32
 {
 	return other += da.convert<Poco::Int32>();
 }
 
 
 inline Poco::Int32 operator -= (Poco::Int32& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from Poco::Int32
+	/// Subtraction assignment operator for subtracting Var from Poco::Int32
 {
 	return other -= da.convert<Poco::Int32>();
 }
 
 
 inline Poco::Int32 operator *= (Poco::Int32& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with Poco::Int32
+	/// Multiplication assignment operator for multiplying Var with Poco::Int32
 {
 	return other *= da.convert<Poco::Int32>();
 }
 
 
 inline Poco::Int32 operator /= (Poco::Int32& other, const Var& da)
-	/// Division asignment operator for dividing Var with Poco::Int32
+	/// Division assignment operator for dividing Var with Poco::Int32
 {
 	return other /= da.convert<Poco::Int32>();
 }
@@ -1546,28 +1546,28 @@ inline Poco::UInt32 operator / (const Poco::UInt32& other, const Var& da)
 
 
 inline Poco::UInt32 operator += (Poco::UInt32& other, const Var& da)
-	/// Addition asignment operator for adding Var to Poco::UInt32
+	/// Addition assignment operator for adding Var to Poco::UInt32
 {
 	return other += da.convert<Poco::UInt32>();
 }
 
 
 inline Poco::UInt32 operator -= (Poco::UInt32& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from Poco::UInt32
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt32
 {
 	return other -= da.convert<Poco::UInt32>();
 }
 
 
 inline Poco::UInt32 operator *= (Poco::UInt32& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with Poco::UInt32
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt32
 {
 	return other *= da.convert<Poco::UInt32>();
 }
 
 
 inline Poco::UInt32 operator /= (Poco::UInt32& other, const Var& da)
-	/// Division asignment operator for dividing Var with Poco::UInt32
+	/// Division assignment operator for dividing Var with Poco::UInt32
 {
 	return other /= da.convert<Poco::UInt32>();
 }
@@ -1650,28 +1650,28 @@ inline Poco::Int64 operator / (const Poco::Int64& other, const Var& da)
 
 
 inline Poco::Int64 operator += (Poco::Int64& other, const Var& da)
-	/// Addition asignment operator for adding Var to Poco::Int64
+	/// Addition assignment operator for adding Var to Poco::Int64
 {
 	return other += da.convert<Poco::Int64>();
 }
 
 
 inline Poco::Int64 operator -= (Poco::Int64& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from Poco::Int64
+	/// Subtraction assignment operator for subtracting Var from Poco::Int64
 {
 	return other -= da.convert<Poco::Int64>();
 }
 
 
 inline Poco::Int64 operator *= (Poco::Int64& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with Poco::Int64
+	/// Multiplication assignment operator for multiplying Var with Poco::Int64
 {
 	return other *= da.convert<Poco::Int64>();
 }
 
 
 inline Poco::Int64 operator /= (Poco::Int64& other, const Var& da)
-	/// Division asignment operator for dividing Var with Poco::Int64
+	/// Division assignment operator for dividing Var with Poco::Int64
 {
 	return other /= da.convert<Poco::Int64>();
 }
@@ -1754,28 +1754,28 @@ inline Poco::UInt64 operator / (const Poco::UInt64& other, const Var& da)
 
 
 inline Poco::UInt64 operator += (Poco::UInt64& other, const Var& da)
-	/// Addition asignment operator for adding Var to Poco::UInt64
+	/// Addition assignment operator for adding Var to Poco::UInt64
 {
 	return other += da.convert<Poco::UInt64>();
 }
 
 
 inline Poco::UInt64 operator -= (Poco::UInt64& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from Poco::UInt64
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt64
 {
 	return other -= da.convert<Poco::UInt64>();
 }
 
 
 inline Poco::UInt64 operator *= (Poco::UInt64& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with Poco::UInt64
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt64
 {
 	return other *= da.convert<Poco::UInt64>();
 }
 
 
 inline Poco::UInt64 operator /= (Poco::UInt64& other, const Var& da)
-	/// Division asignment operator for dividing Var with Poco::UInt64
+	/// Division assignment operator for dividing Var with Poco::UInt64
 {
 	return other /= da.convert<Poco::UInt64>();
 }
@@ -1858,28 +1858,28 @@ inline float operator / (const float& other, const Var& da)
 
 
 inline float operator += (float& other, const Var& da)
-	/// Addition asignment operator for adding Var to float
+	/// Addition assignment operator for adding Var to float
 {
 	return other += da.convert<float>();
 }
 
 
 inline float operator -= (float& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from float
+	/// Subtraction assignment operator for subtracting Var from float
 {
 	return other -= da.convert<float>();
 }
 
 
 inline float operator *= (float& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with float
+	/// Multiplication assignment operator for multiplying Var with float
 {
 	return other *= da.convert<float>();
 }
 
 
 inline float operator /= (float& other, const Var& da)
-	/// Division asignment operator for dividing Var with float
+	/// Division assignment operator for dividing Var with float
 {
 	return other /= da.convert<float>();
 }
@@ -1962,28 +1962,28 @@ inline double operator / (const double& other, const Var& da)
 
 
 inline double operator += (double& other, const Var& da)
-	/// Addition asignment operator for adding Var to double
+	/// Addition assignment operator for adding Var to double
 {
 	return other += da.convert<double>();
 }
 
 
 inline double operator -= (double& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from double
+	/// Subtraction assignment operator for subtracting Var from double
 {
 	return other -= da.convert<double>();
 }
 
 
 inline double operator *= (double& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with double
+	/// Multiplication assignment operator for multiplying Var with double
 {
 	return other *= da.convert<double>();
 }
 
 
 inline double operator /= (double& other, const Var& da)
-	/// Division asignment operator for dividing Var with double
+	/// Division assignment operator for dividing Var with double
 {
 	return other /= da.convert<double>();
 }
@@ -2133,28 +2133,28 @@ inline long operator / (const long& other, const Var& da)
 
 
 inline long operator += (long& other, const Var& da)
-	/// Addition asignment operator for adding Var to long
+	/// Addition assignment operator for adding Var to long
 {
 	return other += da.convert<long>();
 }
 
 
 inline long operator -= (long& other, const Var& da)
-	/// Subtraction asignment operator for subtracting Var from long
+	/// Subtraction assignment operator for subtracting Var from long
 {
 	return other -= da.convert<long>();
 }
 
 
 inline long operator *= (long& other, const Var& da)
-	/// Multiplication asignment operator for multiplying Var with long
+	/// Multiplication assignment operator for multiplying Var with long
 {
 	return other *= da.convert<long>();
 }
 
 
 inline long operator /= (long& other, const Var& da)
-	/// Division asignment operator for dividing Var with long
+	/// Division assignment operator for dividing Var with long
 {
 	return other /= da.convert<long>();
 }

Foundation/include/Poco/ListMap.h

@@ -37,7 +37,7 @@ class ListMap
 	/// ordering of elements is not desirable. Naturally, this container will
 	/// have inferior data retrieval performance and it is not recommended for
 	/// use with large datasets. The main purpose within POCO is for Internet
-	/// messages (email message, http headers etc), to prevent autmomatic 
+	/// messages (email message, http headers etc), to prevent automatic 
 	/// header entry reordering.
 {
 public:

Foundation/include/Poco/LocalDateTime.h

@@ -39,7 +39,7 @@ class Foundation_API LocalDateTime
 	/// i.e. UTC = local time - time zone differential.
 	///
 	/// Although LocalDateTime supports relational and arithmetic
-	/// operators, all date/time comparisons and date/time arithmetics
+	/// operators, all date/time comparisons and date/time arithmetic
 	/// should be done in UTC, using the DateTime or Timestamp
 	/// class for better performance. The relational operators
 	/// normalize the dates/times involved to UTC before carrying out

Foundation/include/Poco/Path.h

@@ -170,7 +170,7 @@ public:
 		/// Appends the given path.
 		
 	Path& resolve(const Path& path);
-		/// Resolves the given path agains the current one.
+		/// Resolves the given path against the current one.
 		///
 		/// If the given path is absolute, it replaces the current one.
 		/// Otherwise, the relative path is appended to the current path.

Foundation/include/Poco/Timestamp.h

@@ -34,7 +34,7 @@ class Foundation_API Timestamp
 	/// A Timestamp stores a monotonic* time value
 	/// with (theoretical) microseconds resolution.
 	/// Timestamps can be compared with each other
-	/// and simple arithmetics are supported.
+	/// and simple arithmetic is supported.
 	///
 	/// [*] Note that Timestamp values are only monotonic as
 	/// long as the systems's clock is monotonic as well