diff --git a/Release/include/cpprest/astreambuf.h b/Release/include/cpprest/astreambuf.h index 872055b463..30e8962e5d 100644 --- a/Release/include/cpprest/astreambuf.h +++ b/Release/include/cpprest/astreambuf.h @@ -343,7 +343,7 @@ namespace streams /// Gets a pointer to the next already allocated contiguous block of data. /// /// A reference to a pointer variable that will hold the address of the block on success. - /// The number of contiguous characters available at the address in 'ptr.' + /// The number of contiguous characters available at the address in 'ptr'. /// true if the operation succeeded, false otherwise. /// /// A return of false does not necessarily indicate that a subsequent read operation would fail, only that @@ -1020,7 +1020,7 @@ namespace streams /// Gets a pointer to the next already allocated contiguous block of data. /// /// A reference to a pointer variable that will hold the address of the block on success. - /// The number of contiguous characters available at the address in 'ptr.' + /// The number of contiguous characters available at the address in 'ptr'. /// true if the operation succeeded, false otherwise. /// /// A return of false does not necessarily indicate that a subsequent read operation would fail, only that diff --git a/Release/include/cpprest/asyncrt_utils.h b/Release/include/cpprest/asyncrt_utils.h index 03bd6fbf90..963d88771e 100644 --- a/Release/include/cpprest/asyncrt_utils.h +++ b/Release/include/cpprest/asyncrt_utils.h @@ -424,7 +424,7 @@ namespace details } /// - /// Cross platform utility function for performing case insensitive string equality comparision. + /// Cross platform utility function for performing case insensitive string equality comparison. /// /// First string to compare. /// Second strong to compare. @@ -432,7 +432,7 @@ namespace details _ASYNCRTIMP bool __cdecl str_iequal(const std::string &left, const std::string &right) CPPREST_NOEXCEPT; /// - /// Cross platform utility function for performing case insensitive string equality comparision. + /// Cross platform utility function for performing case insensitive string equality comparison. /// /// First string to compare. /// Second strong to compare. @@ -440,7 +440,7 @@ namespace details _ASYNCRTIMP bool __cdecl str_iequal(const std::wstring &left, const std::wstring &right) CPPREST_NOEXCEPT; /// - /// Cross platform utility function for performing case insensitive string less-than comparision. + /// Cross platform utility function for performing case insensitive string less-than comparison. /// /// First string to compare. /// Second strong to compare. @@ -448,7 +448,7 @@ namespace details _ASYNCRTIMP bool __cdecl str_iless(const std::string &left, const std::string &right) CPPREST_NOEXCEPT; /// - /// Cross platform utility function for performing case insensitive string less-than comparision. + /// Cross platform utility function for performing case insensitive string less-than comparison. /// /// First string to compare. /// Second strong to compare. diff --git a/Release/include/cpprest/base_uri.h b/Release/include/cpprest/base_uri.h index 9448bb5d35..1aaefe9c2f 100644 --- a/Release/include/cpprest/base_uri.h +++ b/Release/include/cpprest/base_uri.h @@ -94,7 +94,7 @@ namespace web { /// /// A flexible, protocol independent URI implementation. /// - /// URI instances are immutable. Querying the various fields on an emtpy URI will return empty strings. Querying + /// URI instances are immutable. Querying the various fields on an empty URI will return empty strings. Querying /// various diagnostic members on an empty URI will return false. /// /// @@ -305,7 +305,7 @@ namespace web { /// A loopback URI is one which refers to a hostname or ip address with meaning only on the local machine. /// /// - /// Examples include "locahost", or ip addresses in the loopback range (127.0.0.0/24). + /// Examples include "localhost", or ip addresses in the loopback range (127.0.0.0/24). /// /// true if this URI references the local host, false otherwise. bool is_host_loopback() const diff --git a/Release/include/cpprest/containerstream.h b/Release/include/cpprest/containerstream.h index 63ead19f9b..71b2da843a 100644 --- a/Release/include/cpprest/containerstream.h +++ b/Release/include/cpprest/containerstream.h @@ -170,7 +170,7 @@ namespace Concurrency { namespace streams { /// Gets a pointer to the next already allocated contiguous block of data. /// /// A reference to a pointer variable that will hold the address of the block on success. - /// The number of contiguous characters available at the address in 'ptr.' + /// The number of contiguous characters available at the address in 'ptr'. /// true if the operation succeeded, false otherwise. /// /// A return of false does not necessarily indicate that a subsequent read operation would fail, only that diff --git a/Release/include/cpprest/filestream.h b/Release/include/cpprest/filestream.h index b8b982556a..69e14ad373 100644 --- a/Release/include/cpprest/filestream.h +++ b/Release/include/cpprest/filestream.h @@ -311,7 +311,7 @@ namespace details { /// /// Submits a block already allocated by the stream buffer. /// - /// Count of characters to be commited. + /// Count of characters to be committed. void _commit(size_t) { } @@ -320,7 +320,7 @@ namespace details { /// Gets a pointer to the next already allocated contiguous block of data. /// /// A reference to a pointer variable that will hold the address of the block on success. - /// The number of contiguous characters available at the address in 'ptr.' + /// The number of contiguous characters available at the address in 'ptr'. /// true if the operation succeeded, false otherwise. /// /// A return of false does not necessarily indicate that a subsequent read operation would fail, only that @@ -1033,7 +1033,7 @@ namespace details { } /// - /// Open a new ouput stream representing the given file. + /// Open a new output stream representing the given file. /// If the file does not exist, it will be create unless the folder or directory /// where it is to be found also does not exist. /// @@ -1079,7 +1079,7 @@ namespace details { } /// - /// Open a new ouput stream representing the given file. + /// Open a new output stream representing the given file. /// If the file does not exist, it will be create unless the folder or directory /// where it is to be found also does not exist. /// diff --git a/Release/include/cpprest/http_client.h b/Release/include/cpprest/http_client.h index 9ccd19e61f..fef49bd0f2 100644 --- a/Release/include/cpprest/http_client.h +++ b/Release/include/cpprest/http_client.h @@ -257,7 +257,7 @@ class http_client_config /// /// Request that the server respond with a compressed body using Content-Encoding; to use Transfer-Encoding, do not - /// set this, and specify a vector of pointers + /// set this, and specify a vector of pointers /// to the set_decompress_factories method of the object for the request. /// If true and the server does not support compression, this will have no effect. /// The response body is internally decompressed before the consumer receives the data. diff --git a/Release/include/cpprest/http_msg.h b/Release/include/cpprest/http_msg.h index be41832e9d..ae7c498e4d 100644 --- a/Release/include/cpprest/http_msg.h +++ b/Release/include/cpprest/http_msg.h @@ -432,7 +432,7 @@ class http_msg_base /// By default this is an invalid stream. The user could set the instream on /// a request by calling set_request_stream(...). This would also be set when /// set_body() is called - a stream from the body is constructed and set. - /// Even in the presense of msg body this stream could be invalid. An example + /// Even in the presence of msg body this stream could be invalid. An example /// would be when the user sets an ostream for the response. With that API the /// user does not provide the ability to read the msg body. /// Thus m_instream is valid when there is a msg body and it can actually be read diff --git a/Release/include/cpprest/json.h b/Release/include/cpprest/json.h index 1e88ddd2f0..b50650ada9 100644 --- a/Release/include/cpprest/json.h +++ b/Release/include/cpprest/json.h @@ -524,14 +524,14 @@ namespace json /// Compares two JSON values for equality. /// /// The JSON value to compare with. - /// True iff the values are equal. + /// True if the values are equal. _ASYNCRTIMP bool operator==(const value& other) const; /// /// Compares two JSON values for inequality. /// /// The JSON value to compare with. - /// True iff the values are unequal. + /// True if the values are unequal. bool operator!=(const value& other) const { return !((*this) == other); @@ -1226,7 +1226,7 @@ namespace json /// /// Checks if there are any elements in the JSON object. /// - /// True iff empty. + /// True if empty. bool empty() const { return m_elements.empty(); @@ -1374,7 +1374,7 @@ namespace json /// /// Converts the JSON number to unsigned int32. /// - /// An usigned int32 representation of the number + /// An unsigned int32 representation of the number uint32_t to_uint32() const { if (m_type == double_type) @@ -1420,7 +1420,7 @@ namespace json /// Compares two JSON numbers for equality. /// /// The JSON number to compare with. - /// True iff the numbers are equal. + /// True if the numbers are equal. bool operator==(const number &other) const { if (m_type != other.m_type) @@ -1689,7 +1689,7 @@ namespace json utility::string_t m_string; - // There are significant performance gains that can be made by knowning whether + // There are significant performance gains that can be made by knowing whether // or not a character that requires escaping is present. bool m_has_escape_char; static bool has_escape_chars(const _String &str); @@ -1797,7 +1797,7 @@ namespace json for(auto iter = m_object.begin(); iter != m_object.end(); ++iter) { reserveSize += iter->first.length() + 2; // 2 for quotes - size_t valueSize = iter->second.size() * 20; // Multipler by each object/array element + size_t valueSize = iter->second.size() * 20; // Multiply by each object/array element if(valueSize == 0) { if(iter->second.type() == json::value::String) diff --git a/Release/include/cpprest/producerconsumerstream.h b/Release/include/cpprest/producerconsumerstream.h index 4e10872f45..03331d2356 100644 --- a/Release/include/cpprest/producerconsumerstream.h +++ b/Release/include/cpprest/producerconsumerstream.h @@ -178,7 +178,7 @@ namespace Concurrency { namespace streams { /// Gets a pointer to the next already allocated contiguous block of data. /// /// A reference to a pointer variable that will hold the address of the block on success. - /// The number of contiguous characters available at the address in 'ptr.' + /// The number of contiguous characters available at the address in 'ptr'. /// true if the operation succeeded, false otherwise. /// /// A return of false does not necessarily indicate that a subsequent read operation would fail, only that diff --git a/Release/include/cpprest/rawptrstream.h b/Release/include/cpprest/rawptrstream.h index 3fdbb99cb3..c6149040dd 100644 --- a/Release/include/cpprest/rawptrstream.h +++ b/Release/include/cpprest/rawptrstream.h @@ -205,7 +205,7 @@ namespace Concurrency { namespace streams { /// Gets a pointer to the next already allocated contiguous block of data. /// /// A reference to a pointer variable that will hold the address of the block on success. - /// The number of contiguous characters available at the address in 'ptr.' + /// The number of contiguous characters available at the address in 'ptr'. /// true if the operation succeeded, false otherwise. /// /// A return of false does not necessarily indicate that a subsequent read operation would fail, only that diff --git a/Release/include/cpprest/streams.h b/Release/include/cpprest/streams.h index d2923d3774..c409388655 100644 --- a/Release/include/cpprest/streams.h +++ b/Release/include/cpprest/streams.h @@ -496,7 +496,7 @@ namespace Concurrency { namespace streams }; /// - /// Class used to handle asychronous parsing for basic_istream::extract. To support new + /// Class used to handle asynchronous parsing for basic_istream::extract. To support new /// types create a new template specialization and implement the parse function. /// template diff --git a/Release/include/cpprest/ws_client.h b/Release/include/cpprest/ws_client.h index 98f933e149..ff0d414000 100644 --- a/Release/include/cpprest/ws_client.h +++ b/Release/include/cpprest/ws_client.h @@ -142,7 +142,7 @@ class websocket_client_config } /// - /// Gets the server host name to usefor TLS Server Name Indication (SNI). + /// Gets the server host name to use for TLS Server Name Indication (SNI). /// /// Host name as a string. const utf8string & server_name() const diff --git a/Release/include/pplx/pplxcancellation_token.h b/Release/include/pplx/pplxcancellation_token.h index 634e4fafb3..ad729809b7 100644 --- a/Release/include/pplx/pplxcancellation_token.h +++ b/Release/include/pplx/pplxcancellation_token.h @@ -506,7 +506,7 @@ namespace details // // If a cancellation has occurred, the registration list is guaranteed to be empty if we've observed it under the auspices of the - // lock. In this case, we must synchronize with the cancelling thread to guarantee that the cancellation is finished by the time + // lock. In this case, we must synchronize with the canceling thread to guarantee that the cancellation is finished by the time // we return from this method. // if (!_M_registrations.empty()) diff --git a/Release/include/pplx/pplxlinux.h b/Release/include/pplx/pplxlinux.h index 0365f83a30..fe75bc5e8a 100644 --- a/Release/include/pplx/pplxlinux.h +++ b/Release/include/pplx/pplxlinux.h @@ -59,7 +59,7 @@ namespace platform _PPLXIMP void _pplx_cdecl YieldExecution(); /// - /// Caputeres the callstack + /// Captures the callstack /// __declspec(noinline) inline static size_t CaptureCallstack(void **, size_t, size_t) { diff --git a/Release/include/pplx/pplxtasks.h b/Release/include/pplx/pplxtasks.h index e08272cdc7..f7c3f58346 100644 --- a/Release/include/pplx/pplxtasks.h +++ b/Release/include/pplx/pplxtasks.h @@ -203,7 +203,7 @@ template <> class task; /// #if PPL_TASK_SAVE_FRAME_COUNT > 1 #if defined(__cplusplus_winrt) && !defined(_DEBUG) -#pragma message ("WARNING: Redefinning PPL_TASK_SAVE_FRAME_COUNT under Release build for non-desktop applications is not supported; only one frame will be captured!") +#pragma message ("WARNING: Redefining PPL_TASK_SAVE_FRAME_COUNT under Release build for non-desktop applications is not supported; only one frame will be captured!") #define _CAPTURE_CALLSTACK() ::pplx::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()) #else #define _CAPTURE_CALLSTACK() ::pplx::details::_TaskCreationCallstack::_CaptureMultiFramesCallstack(PPL_TASK_SAVE_FRAME_COUNT) @@ -228,7 +228,7 @@ template <> class task; /// the canceled state. If you do not respond and continue execution, or return instead of calling /// cancel_current_task, the task will enter the completed state when it is done. /// state. -/// A task is not cancellable if it was created without a cancellation token. +/// A task is not cancelable if it was created without a cancellation token. /// /// /// @@ -758,7 +758,7 @@ namespace details { // We determine the origin of a task continuation by looking at where .then is called, so we can tell whether // to need to marshal the continuation back to the originating apartment. If an STA thread is in executing in - // a neutral aparment when it schedules a continuation, we will not marshal continuations back to the STA, + // a neutral apartment when it schedules a continuation, we will not marshal continuations back to the STA, // since variables used within a neutral apartment are expected to be apartment neutral. switch(_AptType) { @@ -890,13 +890,13 @@ namespace details std::vector<_Type^> Get() { - // Return vectory with the objects that are marshaled in the proper appartment + // Return vectory with the objects that are marshaled in the proper apartment std::vector<_Type^> _Return; _Return.reserve(_Result.size()); for (auto _PTask = _Result.begin(); _PTask != _Result.end(); ++_PTask) { - _Return.push_back(_PTask->Get()); // Platform::Agile will marshal the object to appropriate appartment if neccessary + _Return.push_back(_PTask->Get()); // Platform::Agile will marshal the object to appropriate apartment if necessary } return _Return; @@ -1147,7 +1147,7 @@ class task_continuation_context : public details::_ContextCallback /// The default continuation context. /// /// - /// The default context is used if you don't specifiy a continuation context when you call the then method. In Windows + /// The default context is used if you don't specify a continuation context when you call the then method. In Windows /// applications for Windows 7 and below, as well as desktop applications on Windows 8 and higher, the runtime determines where /// task continuations will execute. However, in a Windows Store app, the default continuation context for a continuation on an /// apartment aware task is the apartment where then is invoked. @@ -1715,7 +1715,7 @@ namespace details _M_pRegistration(nullptr), _M_Continuations(nullptr), _M_TaskCollection(_Scheduler_arg), _M_taskEventLogger(this) { - // Set cancelation token + // Set cancellation token _M_pTokenState = _PTokenState; _ASSERTE(_M_pTokenState != nullptr); if (_M_pTokenState != _CancellationTokenState::_None()) @@ -1750,7 +1750,7 @@ namespace details else { // Task Continuations are 'scheduled' *inside* the chore that is executing on the ancestors's task group. If a continuation - // needs to be marshalled to a different apartment, instead of scheduling, we make a synchronous cross apartment COM + // needs to be marshaled to a different apartment, instead of scheduling, we make a synchronous cross apartment COM // call to execute the continuation. If it then happens to do something which waits on the ancestor (say it calls .get(), which // task based continuations are wont to do), waiting on the task group results in on the chore that is making this // synchronous callback, which causes a deadlock. To avoid this, we test the state ancestor's event , and we will NOT wait on @@ -1780,8 +1780,8 @@ namespace details // call to wait will receive this status. However, both cancellation and exceptions flowing through // tasks set state in the task impl itself. - // When it returns cancelled, either work chore or the cancel thread should already have set task's state - // properly -- cancelled state or completed state (because there was no interruption point). + // When it returns canceled, either work chore or the cancel thread should already have set task's state + // properly -- canceled state or completed state (because there was no interruption point). // For tasks with unwrapped tasks, we should not change the state of current task, since the unwrapped task are still running. _M_TaskCollection._RunAndWait(); } @@ -2246,7 +2246,7 @@ namespace details } #if _UITHREADCTXT_SUPPORT - // This method is used to throw an exepection in _Wait() if called within STA. We + // This method is used to throw an exception in _Wait() if called within STA. We // want the same behavior if _Wait is called on the UI thread. if (SUCCEEDED(CaptureUiThreadContext(nullptr))) { @@ -2309,7 +2309,7 @@ namespace details // // We must ensure that continuations off _OuterTask (especially exception handling ones) continue to function in the // presence of an exception flowing out of the inner task _UnwrappedTask. This requires an exception handling continuation - // off the inner task which does the appropriate funnelling to the outer one. We use _Then instead of then to prevent + // off the inner task which does the appropriate funneling to the outer one. We use _Then instead of then to prevent // the exception from being marked as observed by our internal continuation. This continuation must be scheduled regardless // of whether or not the _OuterTask task is canceled. // @@ -2450,7 +2450,7 @@ namespace details if (_M_TaskState == _Canceled) { - // If the task has finished cancelling there should not be any continuation records in the array. + // If the task has finished canceling there should not be any continuation records in the array. return false; } else @@ -2734,7 +2734,7 @@ class task_completion_event { for( auto _TaskIt = _Tasks.begin(); _TaskIt != _Tasks.end(); ++_TaskIt ) { - // If current task was cancelled by a cancellation_token, it would be in cancel pending state. + // If current task was canceled by a cancellation_token, it would be in cancel pending state. if ((*_TaskIt)->_IsPendingCancel()) (*_TaskIt)->_Cancel(true); else @@ -3246,8 +3246,8 @@ class task /// cancellation_token_source the token was obtained from. Tasks created without a cancellation token are not cancelable. /// Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface /// reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. Similarly, tasks created - /// from a lamda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, - /// and not when the lamda returns. + /// from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, + /// and not when the lambda returns. /// task behaves like a smart pointer and is safe to pass around by value. It can be accessed by multiple threads /// without the need for locks. /// The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available @@ -3287,8 +3287,8 @@ class task /// cancellation_token_source the token was obtained from. Tasks created without a cancellation token are not cancelable. /// Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface /// reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. Similarly, tasks created - /// from a lamda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, - /// and not when the lamda returns. + /// from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, + /// and not when the lambda returns. /// task behaves like a smart pointer and is safe to pass around by value. It can be accessed by multiple threads /// without the need for locks. /// The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available @@ -3335,8 +3335,8 @@ class task /// cancellation_token_source the token was obtained from. Tasks created without a cancellation token are not cancelable. /// Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface /// reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. Similarly, tasks created - /// from a lamda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, - /// and not when the lamda returns. + /// from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, + /// and not when the lambda returns. /// task behaves like a smart pointer and is safe to pass around by value. It can be accessed by multiple threads /// without the need for locks. /// The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available @@ -3373,8 +3373,8 @@ class task /// cancellation_token_source the token was obtained from. Tasks created without a cancellation token are not cancelable. /// Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface /// reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. Similarly, tasks created - /// from a lamda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, - /// and not when the lamda returns. + /// from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, + /// and not when the lambda returns. /// task behaves like a smart pointer and is safe to pass around by value. It can be accessed by multiple threads /// without the need for locks. /// The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available @@ -3400,8 +3400,8 @@ class task /// cancellation_token_source the token was obtained from. Tasks created without a cancellation token are not cancelable. /// Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface /// reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. Similarly, tasks created - /// from a lamda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, - /// and not when the lamda returns. + /// from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, + /// and not when the lambda returns. /// task behaves like a smart pointer and is safe to pass around by value. It can be accessed by multiple threads /// without the need for locks. /// The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available @@ -3692,7 +3692,7 @@ class task } /// - /// Set the implementation of the task to be the supplied implementaion. + /// Set the implementation of the task to be the supplied implementation. /// void _SetImpl(const typename details::_Task_ptr<_ReturnType>::_Type & _Impl) { @@ -3701,7 +3701,7 @@ class task } /// - /// Set the implementation of the task to be the supplied implementaion using a move instead of a copy. + /// Set the implementation of the task to be the supplied implementation using a move instead of a copy. /// void _SetImpl(typename details::_Task_ptr<_ReturnType>::_Type && _Impl) { @@ -3787,7 +3787,7 @@ class task } // - // Overload 1: returns IAsyncOperation<_InternalReturnType>^ (only uder /ZW) + // Overload 1: returns IAsyncOperation<_InternalReturnType>^ (only under /ZW) // or // returns task<_InternalReturnType> // @@ -3911,7 +3911,7 @@ class task } // - // Overload 0-1: _InternalReturnType -> IAsyncOperation<_TaskType>^ (only uder /ZW) + // Overload 0-1: _InternalReturnType -> IAsyncOperation<_TaskType>^ (only under /ZW) // or // _InternalReturnType -> task<_TaskType> // @@ -4242,8 +4242,8 @@ class task /// cancellation_token_source the token was obtained from. Tasks created without a cancellation token are not cancelable. /// Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface /// reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. Similarly, tasks created - /// from a lamda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, - /// and not when the lamda returns. + /// from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, + /// and not when the lambda returns. /// task behaves like a smart pointer and is safe to pass around by value. It can be accessed by multiple threads /// without the need for locks. /// The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available @@ -4279,8 +4279,8 @@ class task /// cancellation_token_source the token was obtained from. Tasks created without a cancellation token are not cancelable. /// Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface /// reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. Similarly, tasks created - /// from a lamda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, - /// and not when the lamda returns. + /// from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, + /// and not when the lambda returns. /// task behaves like a smart pointer and is safe to pass around by value. It can be accessed by multiple threads /// without the need for locks. /// The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available @@ -4317,8 +4317,8 @@ class task /// cancellation_token_source the token was obtained from. Tasks created without a cancellation token are not cancelable. /// Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface /// reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. Similarly, tasks created - /// from a lamda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, - /// and not when the lamda returns. + /// from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, + /// and not when the lambda returns. /// task behaves like a smart pointer and is safe to pass around by value. It can be accessed by multiple threads /// without the need for locks. /// The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available @@ -4344,8 +4344,8 @@ class task /// cancellation_token_source the token was obtained from. Tasks created without a cancellation token are not cancelable. /// Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface /// reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. Similarly, tasks created - /// from a lamda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, - /// and not when the lamda returns. + /// from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, + /// and not when the lambda returns. /// task behaves like a smart pointer and is safe to pass around by value. It can be accessed by multiple threads /// without the need for locks. /// The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available @@ -4570,7 +4570,7 @@ class task } /// - /// Set the implementation of the task to be the supplied implementaion. + /// Set the implementation of the task to be the supplied implementation. /// void _SetImpl(const details::_Task_ptr::_Type & _Impl) { @@ -4578,7 +4578,7 @@ class task } /// - /// Set the implementation of the task to be the supplied implementaion using a move instead of a copy. + /// Set the implementation of the task to be the supplied implementation using a move instead of a copy. /// void _SetImpl(details::_Task_ptr::_Type && _Impl) { @@ -4691,7 +4691,7 @@ namespace details template _Ty _GetUnwrappedType(task<_Ty>); - // Unwrap all supportted types + // Unwrap all supported types template auto _GetUnwrappedReturnType(_Ty _Arg, int) -> decltype(_GetUnwrappedType(_Arg)); // fallback @@ -5721,7 +5721,7 @@ namespace details _AsyncStatusInternal _Current = _M_currentStatus; // - // Map our internal cancel pending to cancelled. This way "pending cancelled" looks to the outside as "cancelled" but + // Map our internal cancel pending to canceled. This way "pending canceled" looks to the outside as "canceled" but // can still transition to "completed" if the operation completes without acknowledging the cancellation request // switch(_Current) @@ -6244,7 +6244,7 @@ namespace details /// The return type of the lambda determines whether the construct is an action or an operation. /// Lambdas that return void cause the creation of actions. Lambdas that return a result of type TResult cause the creation of /// operations of TResult. -/// The lambda may also return a task<TResult> which encapsulates the aysnchronous work within itself or is the continuation of +/// The lambda may also return a task<TResult> which encapsulates the asynchronous work within itself or is the continuation of /// a chain of tasks that represent the asynchronous work. In this case, the lambda itself is executed inline, since the tasks are the ones that /// execute asynchronously, and the return type of the lambda is unwrapped to produce the asynchronous construct returned by create_async. /// This implies that a lambda that returns a task<void> will cause the creation of actions, and a lambda that returns a task<TResult> will @@ -6255,10 +6255,10 @@ namespace details /// construct which reports progress of type TProgress each time the report method of the progress_reporter object is called. A lambda that /// takes a cancellation_token may use that token to check for cancellation, or pass it to tasks that it creates so that cancellation of the /// asynchronous construct causes cancellation of those tasks. -/// If the body of the lambda or function object returns a result (and not a task<TResult>), the lamdba will be executed +/// If the body of the lambda or function object returns a result (and not a task<TResult>), the lambda will be executed /// asynchronously within the process MTA in the context of a task the Runtime implicitly creates for it. The IAsyncInfo::Cancel method will /// cause cancellation of the implicit task. -/// If the body of the lambda returns a task, the lamba executes inline, and by declaring the lambda to take an argument of type +/// If the body of the lambda returns a task, the lambda executes inline, and by declaring the lambda to take an argument of type /// cancellation_token you can trigger cancellation of any tasks you create within the lambda by passing that token in when you create them. /// You may also use the register_callback method on the token to cause the Runtime to invoke a callback when you call IAsyncInfo::Cancel on /// the async operation or action produced.. @@ -6674,13 +6674,13 @@ namespace details /// The position of the first element beyond the range of elements to be combined into the resulting task. /// /// -/// A task that completes sucessfully when all of the input tasks have completed successfully. If the input tasks are of type T, +/// A task that completes successfully when all of the input tasks have completed successfully. If the input tasks are of type T, /// the output of this function will be a task<std::vector<T>>. If the input tasks are of type void the output /// task will also be a task<void>. /// /// /// If one of the tasks is canceled or throws an exception, the returned task will complete early, in the canceled state, and the exception, -/// if one is encoutered, will be thrown if you call get() or wait() on that task. +/// if one is encountered, will be thrown if you call get() or wait() on that task. /// /// /**/ @@ -6693,7 +6693,7 @@ auto when_all(_Iterator _Begin, _Iterator _End, const task_options& _TaskOptions } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -6713,7 +6713,7 @@ auto when_all(_Iterator _Begin, _Iterator _End, const task_options& _TaskOptions /// /// /// If one of the tasks is canceled or throws an exception, the returned task will complete early, in the canceled state, and the exception, -/// if one is encoutered, will be thrown if you call get() or wait() on that task. +/// if one is encountered, will be thrown if you call get() or wait() on that task. /// /// /**/ @@ -6725,7 +6725,7 @@ auto operator&&(const task<_ReturnType> & _Lhs, const task<_ReturnType> & _Rhs) } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -6745,7 +6745,7 @@ auto operator&&(const task<_ReturnType> & _Lhs, const task<_ReturnType> & _Rhs) /// /// /// If one of the tasks is canceled or throws an exception, the returned task will complete early, in the canceled state, and the exception, -/// if one is encoutered, will be thrown if you call get() or wait() on that task. +/// if one is encountered, will be thrown if you call get() or wait() on that task. /// /// /**/ @@ -6756,7 +6756,7 @@ auto operator&&(const task> & _Lhs, const task<_ReturnT } /// -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -6776,7 +6776,7 @@ auto operator&&(const task> & _Lhs, const task<_ReturnT /// /// /// If one of the tasks is canceled or throws an exception, the returned task will complete early, in the canceled state, and the exception, -/// if one is encoutered, will be thrown if you call get() or wait() on that task. +/// if one is encountered, will be thrown if you call get() or wait() on that task. /// /// /**/ @@ -6787,7 +6787,7 @@ auto operator&&(const task<_ReturnType> & _Lhs, const task -/// Creates a task that will complete succesfully when both of the tasks supplied as arguments complete successfully. +/// Creates a task that will complete successfully when both of the tasks supplied as arguments complete successfully. /// /// /// The type of the returned task. @@ -6807,7 +6807,7 @@ auto operator&&(const task<_ReturnType> & _Lhs, const task /// /// If one of the tasks is canceled or throws an exception, the returned task will complete early, in the canceled state, and the exception, -/// if one is encoutered, will be thrown if you call get() or wait() on that task. +/// if one is encountered, will be thrown if you call get() or wait() on that task. /// /// /**/ @@ -7089,7 +7089,7 @@ auto when_any(_Iterator _Begin, _Iterator _End, cancellation_token _Cancellation /// The second task to combine into the resulting task. /// /// -/// A task that completes sucessfully when either of the input tasks has completed successfully. If the input tasks are of type T, +/// A task that completes successfully when either of the input tasks has completed successfully. If the input tasks are of type T, /// the output of this function will be a task<std::vector<T>. If the input tasks are of type void the output task /// will also be a task<void>. /// To allow for a construct of the sort taskA || taskB && taskC, which are combined in pairs, with && taking precedence @@ -7150,7 +7150,7 @@ task<_ReturnType> operator||(const task<_ReturnType> & _Lhs, const task<_ReturnT /// The second task to combine into the resulting task. /// /// -/// A task that completes sucessfully when either of the input tasks has completed successfully. If the input tasks are of type T, +/// A task that completes successfully when either of the input tasks has completed successfully. If the input tasks are of type T, /// the output of this function will be a task<std::vector<T>. If the input tasks are of type void the output task /// will also be a task<void>. /// To allow for a construct of the sort taskA || taskB && taskC, which are combined in pairs, with && taking precedence @@ -7224,7 +7224,7 @@ task> operator||(const task> & /// The second task to combine into the resulting task. /// /// -/// A task that completes sucessfully when either of the input tasks has completed successfully. If the input tasks are of type T, +/// A task that completes successfully when either of the input tasks has completed successfully. If the input tasks are of type T, /// the output of this function will be a task<std::vector<T>. If the input tasks are of type void the output task /// will also be a task<void>. /// To allow for a construct of the sort taskA || taskB && taskC, which are combined in pairs, with && taking precedence @@ -7256,7 +7256,7 @@ auto operator||(const task<_ReturnType> & _Lhs, const task /// -/// A task that completes sucessfully when either of the input tasks has completed successfully. If the input tasks are of type T, +/// A task that completes successfully when either of the input tasks has completed successfully. If the input tasks are of type T, /// the output of this function will be a task<std::vector<T>. If the input tasks are of type void the output task /// will also be a task<void>. /// To allow for a construct of the sort taskA || taskB && taskC, which are combined in pairs, with && taking precedence diff --git a/Release/src/http/client/http_client_winhttp.cpp b/Release/src/http/client/http_client_winhttp.cpp index 02ffaf057d..f3464c7ae0 100644 --- a/Release/src/http/client/http_client_winhttp.cpp +++ b/Release/src/http/client/http_client_winhttp.cpp @@ -455,12 +455,12 @@ class winhttp_request_context final : public request_context } else if (buffer[n] == '\r') { - // We've reached the end of the size, and there's no chunk extention + // We've reached the end of the size, and there's no chunk extension m_expect_linefeed = true; } else if (buffer[n] == ';') { - // We've reached the end of the size, and there's a chunk extention; + // We've reached the end of the size, and there's a chunk extension; // we don't support extensions, so we ignore them per RFC m_ignore = true; } @@ -1318,7 +1318,7 @@ class winhttp_client final : public _http_client_communicator { const bool defaultChunkSize = pContext->m_http_client->client_config().is_default_chunksize(); - // If user specified a chunk size then read in chunks instead of using query data avaliable. + // If user specified a chunk size then read in chunks instead of using query data available. if (defaultChunkSize) { if (!WinHttpQueryDataAvailable(pContext->m_request_handle, nullptr)) diff --git a/Release/src/http/common/http_msg.cpp b/Release/src/http/common/http_msg.cpp index 91da2c2c3e..7c8a6713f6 100644 --- a/Release/src/http/common/http_msg.cpp +++ b/Release/src/http/common/http_msg.cpp @@ -376,7 +376,7 @@ size_t http_msg_base::_get_content_length(bool honor_compression) content_length = _get_stream_length(); if (content_length != std::numeric_limits::max()) { - // The content length wasn't explcitly set, but we figured it out; + // The content length wasn't explicitly set, but we figured it out; // use it, since sending this way is more efficient than chunking headers().add(header_names::content_length, content_length); return content_length; diff --git a/Release/src/http/listener/http_server_asio.cpp b/Release/src/http/listener/http_server_asio.cpp index 14d75316a7..0d162f41df 100644 --- a/Release/src/http/listener/http_server_asio.cpp +++ b/Release/src/http/listener/http_server_asio.cpp @@ -1342,7 +1342,7 @@ pplx::task http_linux_server::register_listener(http_listener_impl* listen } catch (...) { - // Future improvement - really this API should entirely be asychronously. + // Future improvement - really this API should entirely be asynchronously. // the hostport_listener::start() method should be made to return a task // throwing the exception. m_registered_listeners.erase(listener); diff --git a/Release/src/http/listener/http_server_httpsys.cpp b/Release/src/http/listener/http_server_httpsys.cpp index 9cde3f522e..e882870cbf 100644 --- a/Release/src/http/listener/http_server_httpsys.cpp +++ b/Release/src/http/listener/http_server_httpsys.cpp @@ -420,7 +420,7 @@ void http_windows_server::receive_requests() // Oversubscribe since this is a blocking call and we don't want to count // towards the concurrency runtime's thread count. A more proper fix // would be to use Overlapped I/O and asynchronously call HttpReceiveHttpRequest. - // This requires additional work to be careful sychronizing with the listener + // This requires additional work to be careful synchronizing with the listener // shutdown. This is much easier especially given the http_listener is 'experimental' // and with VS2015 PPL tasks run on the threadpool. #if _MSC_VER < 1900 @@ -918,7 +918,7 @@ void windows_request_context::async_process_response() } if (!m_response._get_impl()->compressor()) { - // Temporarily move the compressor to the reponse, so _get_content_length() will honor it + // Temporarily move the compressor to the response, so _get_content_length() will honor it m_response._get_impl()->set_compressor(std::move(m_compressor)); } // else one was already set from a callback, and we'll (blindly) use it content_length = m_response._get_impl()->_get_content_length_and_set_compression(); diff --git a/Release/src/streams/fileio_posix.cpp b/Release/src/streams/fileio_posix.cpp index ce166957ce..a3690f1070 100644 --- a/Release/src/streams/fileio_posix.cpp +++ b/Release/src/streams/fileio_posix.cpp @@ -54,7 +54,7 @@ struct _file_info_impl : _file_info bool m_buffer_reads; /// - /// A list of callback waiting to be signalled that there are no outstanding writes. + /// A list of callback waiting to be signaled that there are no outstanding writes. /// std::vector<_filestream_callback *> m_sync_waiters; diff --git a/Release/src/streams/fileio_win32.cpp b/Release/src/streams/fileio_win32.cpp index a27c74e11f..cebe72a171 100644 --- a/Release/src/streams/fileio_win32.cpp +++ b/Release/src/streams/fileio_win32.cpp @@ -414,11 +414,11 @@ size_t _write_file_async(_In_ streams::details::_file_info_impl *fInfo, _In_ str DWORD error = GetLastError(); // 1. If WriteFile returned true, it must be because the operation completed immediately. - // The xp threadpool immediatly creates a workerthread to run "_WriteFileCompletionRoutine". + // The xp threadpool immediately creates a workerthread to run "_WriteFileCompletionRoutine". // If this function return value > 0, the condition "if (written == sizeof(_CharType))" in the filestreams.h "_getcImpl()" function will be satisfied. // The main thread will delete the input "callback", while the threadpool workerthread is accessing this "callback"; there will be a race condition and AV error. // We directly return 0 and leave all the completion callbacks working on the workerthread. - // We do not need to call GetOverlappedResult, the workerthread will call the "on_error()" if the WriteFaile falied. + // We do not need to call GetOverlappedResult, the workerthread will call the "on_error()" if the WriteFaile failed. // "req" is deleted in "_WriteFileCompletionRoutine, "pOverlapped" is deleted in io_scheduler::FileIOCompletionRoutine. if (wrResult == TRUE) { @@ -508,11 +508,11 @@ size_t _read_file_async(_In_ streams::details::_file_info_impl *fInfo, _In_ stre DWORD error = GetLastError(); // 1. If ReadFile returned true, it must be because the operation completed immediately. - // The xp threadpool immediatly creates a workerthread to run "_WriteFileCompletionRoutine". + // The xp threadpool immediately creates a workerthread to run "_WriteFileCompletionRoutine". // If this function return value > 0, the condition "if ( ch == sizeof(_CharType) )" in the filestreams.h "_getcImpl()" function will be satisfied. // The main thread will delete the input "callback", while the threadpool workerthread is accessing this "callback"; there will be a race condition and AV error. // We can directly return 0 and leave all the completion callbacks working on the workerthread. - // We do not need to call GetOverlappedResult, the workerthread will call the "on_error()" if the ReadFile falied. + // We do not need to call GetOverlappedResult, the workerthread will call the "on_error()" if the ReadFile failed. // "req" is deleted in "_ReadFileCompletionRoutine, "pOverlapped" is deleted in io_scheduler::FileIOCompletionRoutine. if (wrResult == TRUE) { diff --git a/Release/src/streams/fileio_winrt.cpp b/Release/src/streams/fileio_winrt.cpp index 7585ac15ba..1a206b4e74 100644 --- a/Release/src/streams/fileio_winrt.cpp +++ b/Release/src/streams/fileio_winrt.cpp @@ -540,7 +540,7 @@ size_t __cdecl _putn_fsb(_In_ Concurrency::streams::details::_file_info *info, _ // In most of the time, we preserve the writer so that it would have better performance. - // However, after uer call seek, we will despose old writer. By doing so, users could + // However, after user call seek, we will dispose old writer. By doing so, users could // write to new writer in new position while the old writer is still flushing data into stream. if (fInfo->m_writer == nullptr) {