generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-03-24 15:57:19 +01: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
* following operations:
*

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

@ -37,7 +37,7 @@ class CryptoTransform;
class Crypto_API Cipher: public Poco::RefCountedObject
/// 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:
///
/// 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
/// 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
/// encrypted data in e-mails), the encryptString() and decryptString() can
/// 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
/// 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
/// crypto library.
///

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

@ -41,10 +41,10 @@ public:
/// Destroys the bulk.
const Limit& limit() const;
/// Returns the limit asociated with this bulk object.
/// Returns the limit associated with this bulk object.
Poco::UInt32 size() const;
/// Returns the value of the limit asociated with
/// Returns the value of the limit associated with
/// this bulk object.
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.
///
/// 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.
/// It takes ownership of the Column pointer supplied as constructor argument. Column object, in turn
/// 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.
///
/// 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.
/// It takes ownership of the Column pointer supplied as constructor argument. Column object, in turn
/// 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.
///
/// * 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
/// the target, the previous operation must have been either completed
/// 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
/// 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.

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

@ -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>();
}

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

@ -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:

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

@ -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

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

@ -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.

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

@ -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

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

@ -53,14 +53,14 @@ public:
void startObject();
/// 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();
/// The parser has read a '}'; the object is closed.
void startArray();
/// 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();
/// 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:
TCPServer(TCPServerConnectionFactory::Ptr pFactory, Poco::UInt16 portNumber = 0, TCPServerParams::Ptr pParams = 0);
/// 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.
///
/// 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.
///
/// 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
/// also found.
///