generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-04-06 10:55:59 +02:00
Code Issues Projects Releases Wiki Activity

Corrected other misspelt 'a' words.

Browse Source
This commit is contained in:
martin-osborne 2015-04-06 17:34:48 +01:00
parent 91dd5f8e44
commit 7e730aa9b8
16 changed files with 75 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CppUnit/include/CppUnit/Orthodox.h
View File

@ -17,7 +17,7 @@ namespace CppUnit {
/* /*
* Orthodox performs a simple set of tests on an arbitary * Orthodox performs a simple set of tests on an arbitrary
* class to make sure that it supports at least the * class to make sure that it supports at least the
* following operations: * following operations:
* *

4
Crypto/include/Poco/Crypto/Cipher.h
View File

@ -37,7 +37,7 @@ class CryptoTransform;
class Crypto_API Cipher: public Poco::RefCountedObject class Crypto_API Cipher: public Poco::RefCountedObject
/// Represents the abstract base class from which all implementations of /// Represents the abstract base class from which all implementations of
/// symmetric/assymetric encryption algorithms must inherit. Use the CipherFactory /// symmetric/asymmetric encryption algorithms must inherit. Use the CipherFactory
/// class to obtain an instance of this class: /// class to obtain an instance of this class:
/// ///
/// CipherFactory& factory = CipherFactory::defaultFactory(); /// CipherFactory& factory = CipherFactory::defaultFactory();
@ -57,7 +57,7 @@ class Crypto_API Cipher: public Poco::RefCountedObject
/// decrypt strings or, in conjunction with a CryptoInputStream or a /// decrypt strings or, in conjunction with a CryptoInputStream or a
/// CryptoOutputStream, to encrypt streams of data. /// CryptoOutputStream, to encrypt streams of data.
/// ///
/// Since encrypted strings will contain arbitary binary data that will cause /// Since encrypted strings will contain arbitrary binary data that will cause
/// problems in applications that are not binary-safe (eg., when sending /// problems in applications that are not binary-safe (eg., when sending
/// encrypted data in e-mails), the encryptString() and decryptString() can /// encrypted data in e-mails), the encryptString() and decryptString() can
/// encode (or decode, respectively) encrypted data using a "transport encoding". /// encode (or decode, respectively) encrypted data using a "transport encoding".

2
Crypto/include/Poco/Crypto/RSACipherImpl.h
View File

@ -33,7 +33,7 @@ namespace Crypto {
class RSACipherImpl: public Cipher class RSACipherImpl: public Cipher
/// An implementation of the Cipher class for /// An implementation of the Cipher class for
/// assymetric (public-private key) encryption /// asymmetric (public-private key) encryption
/// based on the the RSA algorithm in OpenSSL's /// based on the the RSA algorithm in OpenSSL's
/// crypto library. /// crypto library.
/// ///

4
Data/include/Poco/Data/Bulk.h
View File

@ -41,10 +41,10 @@ public:
/// Destroys the bulk. /// Destroys the bulk.
const Limit& limit() const; const Limit& limit() const;
/// Returns the limit asociated with this bulk object. /// Returns the limit associated with this bulk object.
Poco::UInt32 size() const; Poco::UInt32 size() const;
/// Returns the value of the limit asociated with /// Returns the value of the limit associated with
/// this bulk object. /// this bulk object.
private: private:

2
Data/include/Poco/Data/BulkExtraction.h
View File

@ -139,7 +139,7 @@ class InternalBulkExtraction: public BulkExtraction<C>
/// Container Data Type specialization extension for extraction of values from a query result set. /// Container Data Type specialization extension for extraction of values from a query result set.
/// ///
/// This class is intended for PocoData internal use - it is used by StatementImpl /// This class is intended for PocoData internal use - it is used by StatementImpl
/// to automaticaly create internal BulkExtraction in cases when statement returns data and no external storage /// to automatically create internal BulkExtraction in cases when statement returns data and no external storage
/// was supplied. It is later used by RecordSet to retrieve the fetched data after statement execution. /// was supplied. It is later used by RecordSet to retrieve the fetched data after statement execution.
/// It takes ownership of the Column pointer supplied as constructor argument. Column object, in turn /// It takes ownership of the Column pointer supplied as constructor argument. Column object, in turn
/// owns the data container pointer. /// owns the data container pointer.

2
Data/include/Poco/Data/Extraction.h
View File

@ -497,7 +497,7 @@ class InternalExtraction: public Extraction<C>
/// Container Data Type specialization extension for extraction of values from a query result set. /// Container Data Type specialization extension for extraction of values from a query result set.
/// ///
/// This class is intended for PocoData internal use - it is used by StatementImpl /// This class is intended for PocoData internal use - it is used by StatementImpl
/// to automaticaly create internal Extraction in cases when statement returns data and no external storage /// to automatically create internal Extraction in cases when statement returns data and no external storage
/// was supplied. It is later used by RecordSet to retrieve the fetched data after statement execution. /// was supplied. It is later used by RecordSet to retrieve the fetched data after statement execution.
/// It takes ownership of the Column pointer supplied as constructor argument. Column object, in turn /// It takes ownership of the Column pointer supplied as constructor argument. Column object, in turn
/// owns the data container pointer. /// owns the data container pointer.

2
Data/include/Poco/Data/SQLChannel.h
View File

@ -105,7 +105,7 @@ public:
/// set this property to empty string. /// set this property to empty string.
/// ///
/// * async: Indicates asynchronous execution. When excuting asynchronously, /// * async: Indicates asynchronous execution. When excuting asynchronously,
/// messages are sent to the target using asyncronous execution. /// messages are sent to the target using asynchronous execution.
/// However, prior to the next message being processed and sent to /// However, prior to the next message being processed and sent to
/// the target, the previous operation must have been either completed /// the target, the previous operation must have been either completed
/// or timed out (see timeout and throw properties for details on /// or timed out (see timeout and throw properties for details on

2
Foundation/include/Poco/Clock.h
View File

@ -30,7 +30,7 @@ class Foundation_API Clock
/// A Clock stores a monotonic* clock value /// A Clock stores a monotonic* clock value
/// with (theoretical) microseconds resolution. /// with (theoretical) microseconds resolution.
/// Clocks can be compared with each other /// 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 /// [*] Note that Clock values are only monotonic if
/// the operating system provides a monotonic clock. /// the operating system provides a monotonic clock.

114
Foundation/include/Poco/Dynamic/Var.h
View File

@ -271,16 +271,16 @@ public:
template <typename T> template <typename T>
Var& operator += (const T& other) 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; return *this = convert<T>() + other;
} }
Var& operator += (const Var& other); Var& operator += (const Var& other);
/// Addition asignment operator overload for Var /// Addition assignment operator overload for Var
Var& operator += (const char* other); Var& operator += (const char* other);
/// Addition asignment operator overload for const char* /// Addition assignment operator overload for const char*
template <typename T> template <typename T>
const Var operator - (const T& other) const const Var operator - (const T& other) const
@ -294,13 +294,13 @@ public:
template <typename T> template <typename T>
Var& operator -= (const T& other) Var& operator -= (const T& other)
/// Subtraction asignment operator /// Subtraction assignment operator
{ {
return *this = convert<T>() - other; return *this = convert<T>() - other;
} }
Var& operator -= (const Var& other); Var& operator -= (const Var& other);
/// Subtraction asignment operator overload for Var /// Subtraction assignment operator overload for Var
template <typename T> template <typename T>
const Var operator * (const T& other) const const Var operator * (const T& other) const
@ -314,13 +314,13 @@ public:
template <typename T> template <typename T>
Var& operator *= (const T& other) Var& operator *= (const T& other)
/// Multiplication asignment operator /// Multiplication assignment operator
{ {
return *this = convert<T>() * other; return *this = convert<T>() * other;
} }
Var& operator *= (const Var& other); Var& operator *= (const Var& other);
/// Multiplication asignment operator overload for Var /// Multiplication assignment operator overload for Var
template <typename T> template <typename T>
const Var operator / (const T& other) const const Var operator / (const T& other) const
@ -334,13 +334,13 @@ public:
template <typename T> template <typename T>
Var& operator /= (const T& other) Var& operator /= (const T& other)
/// Division asignment operator /// Division assignment operator
{ {
return *this = convert<T>() / other; return *this = convert<T>() / other;
} }
Var& operator /= (const Var& other); Var& operator /= (const Var& other);
/// Division asignment operator specialization for Var /// Division assignment operator specialization for Var
template <typename T> template <typename T>
bool operator == (const T& other) const 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) 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>(); return other += da.convert<char>();
} }
inline char operator -= (char& other, const Var& da) 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>(); return other -= da.convert<char>();
} }
inline char operator *= (char& other, const Var& da) 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>(); return other *= da.convert<char>();
} }
inline char operator /= (char& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<Poco::Int8>();
} }
inline Poco::Int8 operator -= (Poco::Int8& other, const Var& da) 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>(); return other -= da.convert<Poco::Int8>();
} }
inline Poco::Int8 operator *= (Poco::Int8& other, const Var& da) 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>(); return other *= da.convert<Poco::Int8>();
} }
inline Poco::Int8 operator /= (Poco::Int8& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<Poco::UInt8>();
} }
inline Poco::UInt8 operator -= (Poco::UInt8& other, const Var& da) 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>(); return other -= da.convert<Poco::UInt8>();
} }
inline Poco::UInt8 operator *= (Poco::UInt8& other, const Var& da) 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>(); return other *= da.convert<Poco::UInt8>();
} }
inline Poco::UInt8 operator /= (Poco::UInt8& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<Poco::Int16>();
} }
inline Poco::Int16 operator -= (Poco::Int16& other, const Var& da) 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>(); return other -= da.convert<Poco::Int16>();
} }
inline Poco::Int16 operator *= (Poco::Int16& other, const Var& da) 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>(); return other *= da.convert<Poco::Int16>();
} }
inline Poco::Int16 operator /= (Poco::Int16& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<Poco::UInt16>();
} }
inline Poco::UInt16 operator -= (Poco::UInt16& other, const Var& da) 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>(); return other -= da.convert<Poco::UInt16>();
} }
inline Poco::UInt16 operator *= (Poco::UInt16& other, const Var& da) 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>(); return other *= da.convert<Poco::UInt16>();
} }
inline Poco::UInt16 operator /= (Poco::UInt16& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<Poco::Int32>();
} }
inline Poco::Int32 operator -= (Poco::Int32& other, const Var& da) 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>(); return other -= da.convert<Poco::Int32>();
} }
inline Poco::Int32 operator *= (Poco::Int32& other, const Var& da) 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>(); return other *= da.convert<Poco::Int32>();
} }
inline Poco::Int32 operator /= (Poco::Int32& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<Poco::UInt32>();
} }
inline Poco::UInt32 operator -= (Poco::UInt32& other, const Var& da) 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>(); return other -= da.convert<Poco::UInt32>();
} }
inline Poco::UInt32 operator *= (Poco::UInt32& other, const Var& da) 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>(); return other *= da.convert<Poco::UInt32>();
} }
inline Poco::UInt32 operator /= (Poco::UInt32& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<Poco::Int64>();
} }
inline Poco::Int64 operator -= (Poco::Int64& other, const Var& da) 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>(); return other -= da.convert<Poco::Int64>();
} }
inline Poco::Int64 operator *= (Poco::Int64& other, const Var& da) 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>(); return other *= da.convert<Poco::Int64>();
} }
inline Poco::Int64 operator /= (Poco::Int64& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<Poco::UInt64>();
} }
inline Poco::UInt64 operator -= (Poco::UInt64& other, const Var& da) 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>(); return other -= da.convert<Poco::UInt64>();
} }
inline Poco::UInt64 operator *= (Poco::UInt64& other, const Var& da) 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>(); return other *= da.convert<Poco::UInt64>();
} }
inline Poco::UInt64 operator /= (Poco::UInt64& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<float>();
} }
inline float operator -= (float& other, const Var& da) 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>(); return other -= da.convert<float>();
} }
inline float operator *= (float& other, const Var& da) 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>(); return other *= da.convert<float>();
} }
inline float operator /= (float& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<double>();
} }
inline double operator -= (double& other, const Var& da) 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>(); return other -= da.convert<double>();
} }
inline double operator *= (double& other, const Var& da) 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>(); return other *= da.convert<double>();
} }
inline double operator /= (double& other, const Var& da) 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>(); 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) 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>(); return other += da.convert<long>();
} }
inline long operator -= (long& other, const Var& da) 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>(); return other -= da.convert<long>();
} }
inline long operator *= (long& other, const Var& da) 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>(); return other *= da.convert<long>();
} }
inline long operator /= (long& other, const Var& da) 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>(); return other /= da.convert<long>();
} }

2
Foundation/include/Poco/ListMap.h
View File

@ -37,7 +37,7 @@ class ListMap
/// ordering of elements is not desirable. Naturally, this container will /// ordering of elements is not desirable. Naturally, this container will
/// have inferior data retrieval performance and it is not recommended for /// have inferior data retrieval performance and it is not recommended for
/// use with large datasets. The main purpose within POCO is for Internet /// 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. /// header entry reordering.
{ {
public: public:

2
Foundation/include/Poco/LocalDateTime.h
View File

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

2
Foundation/include/Poco/Path.h
View File

@ -170,7 +170,7 @@ public:
/// Appends the given path. /// Appends the given path.
Path& resolve(const Path& 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. /// If the given path is absolute, it replaces the current one.
/// Otherwise, the relative path is appended to the current path. /// Otherwise, the relative path is appended to the current path.

2
Foundation/include/Poco/Timestamp.h
View File

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

4
JSON/include/Poco/JSON/PrintHandler.h
View File

@ -53,14 +53,14 @@ public:
void startObject(); void startObject();
/// The parser has read a '{'; a new object is started. /// The parser has read a '{'; a new object is started.
/// If indent is greater than zero, a newline will be apended. /// If indent is greater than zero, a newline will be appended.
void endObject(); void endObject();
/// The parser has read a '}'; the object is closed. /// The parser has read a '}'; the object is closed.
void startArray(); void startArray();
/// The parser has read a [; a new array will be started. /// The parser has read a [; a new array will be started.
/// If indent is greater than zero, a newline will be apended. /// If indent is greater than zero, a newline will be appended.
void endArray(); void endArray();
/// The parser has read a ]; the array is closed. /// The parser has read a ]; the array is closed.

2
Net/include/Poco/Net/TCPServer.h
View File

@ -80,7 +80,7 @@ class Net_API TCPServer: public Poco::Runnable
public: public:
TCPServer(TCPServerConnectionFactory::Ptr pFactory, Poco::UInt16 portNumber = 0, TCPServerParams::Ptr pParams = 0); TCPServer(TCPServerConnectionFactory::Ptr pFactory, Poco::UInt16 portNumber = 0, TCPServerParams::Ptr pParams = 0);
/// Creates the TCPServer, with ServerSocket listening on the given port. /// Creates the TCPServer, with ServerSocket listening on the given port.
/// Default port is zero, allowing any availble port. The port number /// Default port is zero, allowing any available port. The port number
/// can be queried through TCPServer::port() member. /// can be queried through TCPServer::port() member.
/// ///
/// The server takes ownership of the TCPServerConnectionFactory /// The server takes ownership of the TCPServerConnectionFactory

2
Util/include/Poco/Util/Application.h
View File

@ -189,7 +189,7 @@ public:
/// by the .ini file and the .xml file. /// by the .ini file and the .xml file.
/// ///
/// If the application is built in debug mode (the _DEBUG preprocessor /// If the application is built in debug mode (the _DEBUG preprocessor
/// macro is defined) and the base name of the appication executable /// macro is defined) and the base name of the application executable
/// ends with a 'd', a config file without the 'd' ending its base name is /// ends with a 'd', a config file without the 'd' ending its base name is
/// also found. /// also found.
/// ///