text:
namespace Fixtures.AcceptanceTestsHttp
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Rest;
    using Models;

    public static partial class MultipleResponsesExtensions
    {
            /// <summary>
            /// Send a 200 response with valid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200Model204NoModelDefaultError200Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200Model204NoModelDefaultError200ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200Model204NoModelDefaultError200ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200Model204NoModelDefaultError200ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 204 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200Model204NoModelDefaultError204Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200Model204NoModelDefaultError204ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 204 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200Model204NoModelDefaultError204ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200Model204NoModelDefaultError204ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 201 response with valid payload: {'statusCode': '201'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200Model204NoModelDefaultError201Invalid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200Model204NoModelDefaultError201InvalidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 201 response with valid payload: {'statusCode': '201'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200Model204NoModelDefaultError201InvalidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200Model204NoModelDefaultError201InvalidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 202 response with no payload:
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200Model204NoModelDefaultError202None(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200Model204NoModelDefaultError202NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 202 response with no payload:
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200Model204NoModelDefaultError202NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200Model204NoModelDefaultError202NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 400 response with valid error payload: {'status': 400, 'message':
            /// 'client error'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200Model204NoModelDefaultError400Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200Model204NoModelDefaultError400ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with valid error payload: {'status': 400, 'message':
            /// 'client error'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200Model204NoModelDefaultError400ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200Model204NoModelDefaultError400ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200Model201ModelDefaultError200Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200Model201ModelDefaultError200ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200Model201ModelDefaultError200ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200Model201ModelDefaultError200ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 201 response with valid payload: {'statusCode': '201',
            /// 'textStatusCode': 'Created'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200Model201ModelDefaultError201Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200Model201ModelDefaultError201ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 201 response with valid payload: {'statusCode': '201',
            /// 'textStatusCode': 'Created'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200Model201ModelDefaultError201ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200Model201ModelDefaultError201ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'code': '400', 'message': 'client
            /// error'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200Model201ModelDefaultError400Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200Model201ModelDefaultError400ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'code': '400', 'message': 'client
            /// error'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200Model201ModelDefaultError400ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200Model201ModelDefaultError400ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static object Get200ModelA201ModelC404ModelDDefaultError200Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA201ModelC404ModelDDefaultError200ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<object> Get200ModelA201ModelC404ModelDDefaultError200ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<object> result = await operations.Get200ModelA201ModelC404ModelDDefaultError200ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'httpCode': '201'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static object Get200ModelA201ModelC404ModelDDefaultError201Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA201ModelC404ModelDDefaultError201ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'httpCode': '201'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<object> Get200ModelA201ModelC404ModelDDefaultError201ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<object> result = await operations.Get200ModelA201ModelC404ModelDDefaultError201ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'httpStatusCode': '404'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static object Get200ModelA201ModelC404ModelDDefaultError404Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA201ModelC404ModelDDefaultError404ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'httpStatusCode': '404'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<object> Get200ModelA201ModelC404ModelDDefaultError404ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<object> result = await operations.Get200ModelA201ModelC404ModelDDefaultError404ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'code': '400', 'message': 'client
            /// error'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static object Get200ModelA201ModelC404ModelDDefaultError400Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA201ModelC404ModelDDefaultError400ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'code': '400', 'message': 'client
            /// error'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<object> Get200ModelA201ModelC404ModelDDefaultError400ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<object> result = await operations.Get200ModelA201ModelC404ModelDDefaultError400ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 202 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void Get202None204NoneDefaultError202None(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).Get202None204NoneDefaultError202NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 202 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task Get202None204NoneDefaultError202NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.Get202None204NoneDefaultError202NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 204 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void Get202None204NoneDefaultError204None(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).Get202None204NoneDefaultError204NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 204 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task Get202None204NoneDefaultError204NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.Get202None204NoneDefaultError204NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'code': '400', 'message': 'client
            /// error'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void Get202None204NoneDefaultError400Valid(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).Get202None204NoneDefaultError400ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'code': '400', 'message': 'client
            /// error'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task Get202None204NoneDefaultError400ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.Get202None204NoneDefaultError400ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 202 response with an unexpected payload {'property': 'value'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void Get202None204NoneDefaultNone202Invalid(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).Get202None204NoneDefaultNone202InvalidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 202 response with an unexpected payload {'property': 'value'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task Get202None204NoneDefaultNone202InvalidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.Get202None204NoneDefaultNone202InvalidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 204 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void Get202None204NoneDefaultNone204None(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).Get202None204NoneDefaultNone204NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 204 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task Get202None204NoneDefaultNone204NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.Get202None204NoneDefaultNone204NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 400 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void Get202None204NoneDefaultNone400None(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).Get202None204NoneDefaultNone400NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task Get202None204NoneDefaultNone400NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.Get202None204NoneDefaultNone400NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 400 response with an unexpected payload {'property': 'value'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void Get202None204NoneDefaultNone400Invalid(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).Get202None204NoneDefaultNone400InvalidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with an unexpected payload {'property': 'value'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task Get202None204NoneDefaultNone400InvalidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.Get202None204NoneDefaultNone400InvalidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A GetDefaultModelA200Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).GetDefaultModelA200ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with valid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> GetDefaultModelA200ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.GetDefaultModelA200ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A GetDefaultModelA200None(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).GetDefaultModelA200NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> GetDefaultModelA200NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.GetDefaultModelA200NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'statusCode': '400'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A GetDefaultModelA400Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).GetDefaultModelA400ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'statusCode': '400'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> GetDefaultModelA400ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.GetDefaultModelA400ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 400 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A GetDefaultModelA400None(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).GetDefaultModelA400NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> GetDefaultModelA400NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.GetDefaultModelA400NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with invalid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void GetDefaultNone200Invalid(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).GetDefaultNone200InvalidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with invalid payload: {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task GetDefaultNone200InvalidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.GetDefaultNone200InvalidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 200 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void GetDefaultNone200None(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).GetDefaultNone200NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task GetDefaultNone200NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.GetDefaultNone200NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'statusCode': '400'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void GetDefaultNone400Invalid(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).GetDefaultNone400InvalidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with valid payload: {'statusCode': '400'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task GetDefaultNone400InvalidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.GetDefaultNone400InvalidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 400 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static void GetDefaultNone400None(this IMultipleResponses operations)
            {
                Task.Factory.StartNew(s => ((IMultipleResponses)s).GetDefaultNone400NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with no payload
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task GetDefaultNone400NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                await operations.GetDefaultNone400NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
            }

            /// <summary>
            /// Send a 200 response with no payload, when a payload is expected - client
            /// should return a null object of thde type for model A
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200ModelA200None(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA200NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with no payload, when a payload is expected - client
            /// should return a null object of thde type for model A
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200ModelA200NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200ModelA200NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with payload {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200ModelA200Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA200ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with payload {'statusCode': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200ModelA200ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200ModelA200ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with invalid payload {'statusCodeInvalid': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200ModelA200Invalid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA200InvalidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with invalid payload {'statusCodeInvalid': '200'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200ModelA200InvalidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200ModelA200InvalidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 400 response with no payload client should treat as an http error
            /// with no error model
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200ModelA400None(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA400NoneAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 400 response with no payload client should treat as an http error
            /// with no error model
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200ModelA400NoneAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200ModelA400NoneWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with payload {'statusCode': '400'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200ModelA400Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA400ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with payload {'statusCode': '400'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200ModelA400ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200ModelA400ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 200 response with invalid payload {'statusCodeInvalid': '400'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200ModelA400Invalid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA400InvalidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 200 response with invalid payload {'statusCodeInvalid': '400'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200ModelA400InvalidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200ModelA400InvalidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

            /// <summary>
            /// Send a 202 response with payload {'statusCode': '202'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            public static A Get200ModelA202Valid(this IMultipleResponses operations)
            {
                return Task.Factory.StartNew(s => ((IMultipleResponses)s).Get200ModelA202ValidAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
            }

            /// <summary>
            /// Send a 202 response with payload {'statusCode': '202'}
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<A> Get200ModelA202ValidAsync( this IMultipleResponses operations, CancellationToken cancellationToken = default(CancellationToken))
            {
                HttpOperationResponse<A> result = await operations.Get200ModelA202ValidWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false);
                return result.Body;
            }

    }
}


text: #include "../../../../../modules/juce_audio_processors/juce_audio_processors.h"

redpajama_set_name: RedPajamaGithub


text:
module PagseguroClient
  class Transaction
    PAYMENT_METHOD = {
      1 => :credit_card,
      2 => :invoice,
      3 => :online_transfer,
      4 => :pagseguro,
      5 => :oi_paggo
    }

    STATUS = {
      1 => :pending,
      2 => :verifying,
      3 => :approved,
      4 => :available,
      6 => :refunded,
      7 => :canceled
    }

    SHIPPING_TYPE = {
      1 => :pac,
      2 => :sedex
    }

    attr_accessor :code, :order_id, :status, :payment_method, :last_event_date, :sender, :address, :shipping

    def initialize(attributes = {})
      attributes.each do |name, value|
        send("#{name}=", value)
      end
    end

    def self.create_by_xml(xml)
      doc = Nokogiri::XML(xml)
      code = doc.xpath("//transaction/code").text
      order_id = doc.xpath("//reference").text
      status = doc.xpath("//status").text.to_i
      payment_method = doc.xpath("//paymentMethod/type").text.to_i
      last_event_date = doc.xpath("//transaction/lastEventDate").text
      email = doc.xpath("//transaction/sender/email").text
      name = doc.xpath("//transaction/sender/name").text
      phone = {
        area_code: doc.xpath("//transaction/sender/phone/areaCode").text,
        number: doc.xpath("//transaction/sender/phone/number").text
      }

      address = {
        country: doc.xpath("//transaction/shipping/address/country").text,
        state: doc.xpath("//transaction/shipping/address/state").text,
        city: doc.xpath("//transaction/shipping/address/city").text,
        postal_code: doc.xpath("//transaction/shipping/address/postalCode").text,
        district: doc.xpath("//transaction/shipping/address/district").text,
        street: doc.xpath("//transaction/shipping/address/street").text,
        number: doc.xpath("//transaction/shipping/address/number").text,
        complement: doc.xpath("//transaction/shipping/address/complement").text
      }

      shipping = {
        type: SHIPPING_TYPE[doc.xpath("//transaction/shipping/type").text.to_i],
        cost: doc.xpath("//transaction/shipping/cost").text.to_f
      }

      transaction = Transaction.new(
        code: code,
        order_id: order_id,
        status: STATUS[status],
        payment_method: PAYMENT_METHOD[payment_method],
        sender: {
          name: name,
          email: email,
          phone: phone
        },
        address: address,
        last_event_date: last_event_date,
        shipping: shipping
      )
    end

    def self.url(code)
      PagseguroClient.transaction_url(code)
    end

    def self.retrieve(code)
      response = RestClient.get(url(code),
        {
          params: {
            email: PagseguroClient.email,
            token: PagseguroClient.token
          }
        }
      )

      create_by_xml(response.body)
    end
  end
end


text:
public static SinglyLinkedListNode insertNodeAtPosition(SinglyLinkedListNode head, int data, int position) {
    SinglyLinkedListNode newHead = head, prev = null, aux;

    for (; head != null && position > 0; prev = head, head = head.next, position--);

    aux = new SinglyLinkedListNode(data);

    if (prev == null) {
        aux.next = head;

        newHead = aux;
    } else {
        aux.next = prev.next;

        prev.next = aux;
    }

    return newHead;
}


text:
namespace H3Mapper.MapObjects
{
    public enum MagicShrineSpellLevel
    {
        One,
        Two,
        Three,
        Four // HotA only
    }
}


text:
package cn.ifavor.quickindexview.tools;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

public class PinyinUtils {

	/**
	 * ¸ù¾Ý´«ÈëµÄ×Ö·û´®(°üº¬ºº×Ö),µÃµ½Æ´Òô ºÚÂí -> HEIMA ºÚ Âí*& -> HEIMA ºÚÂíf5 -> HEIMA
	 *
	 * @param str
	 *            ×Ö·û´®
	 * @return
	 */
	public static String getPinyin(String str) {

		HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
		format.setCaseType(HanyuPinyinCaseType.UPPERCASE);
		format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);

		StringBuilder sb = new StringBuilder();

		char[] charArray = str.toCharArray();
		for (int i = 0; i < charArray.length; i++) {
			char c = charArray[i];
			// Èç¹ûÊÇ¿Õ¸ñ, Ìø¹ý
			if (Character.isWhitespace(c)) {
				continue;
			}
			if (c >= -127 && c < 128) {
				// ¿Ï¶¨²»ÊǺº×Ö
				sb.append(c);
			} else {
				String s = "";
				try {
					// ͨ¹ýcharµÃµ½Æ´Òô¼¯ºÏ. µ¥ -> dan, shan
					s = PinyinHelper.toHanyuPinyinStringArray(c, format)[0];
					sb.append(s);
				} catch (BadHanyuPinyinOutputFormatCombination e) {
					e.printStackTrace();
					sb.append(s);
				}
			}
		}

		return sb.toString();
	}

}


text:
<?xml version="1.0" encoding="ISO-8859-1"?>
<geo:GeodesyML xsi:schemaLocation="urn:xml-gov-au:icsm:egeodesy:0.3" xmlns:geo="urn:xml-gov-au:icsm:egeodesy:0.3" xmlns:gml="http://www.opengis.net/gml/3.2" xmlns:ns9="http://www.w3.org/1999/xlink" xmlns:gmd="http://www.isotc211.org/2005/gmd" xmlns:gmx="http://www.isotc211.org/2005/gmx" xmlns:om="http://www.opengis.net/om/2.0" xmlns:gco="http://www.isotc211.org/2005/gco" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" gml:id="GeodesyMLType_365">
   <geo:siteLog gml:id="SiteLogType_365">
      <geo:formInformation>
         <geo:preparedBy>Volker Janssen</geo:preparedBy>
         <geo:datePrepared>2013-01-20T13:00:00Z</geo:datePrepared>
         <geo:reportType>UPDATE</geo:reportType>
      </geo:formInformation>
      <geo:siteIdentification>
         <geo:siteName>Menangle</geo:siteName>
         <geo:fourCharacterID>MENA</geo:fourCharacterID>
         <geo:iersDOMESNumber>AUM000158</geo:iersDOMESNumber>
         <geo:cdpNumber></geo:cdpNumber>
         <geo:monumentDescription>GALVANISED STEEL POLE</geo:monumentDescription>
         <geo:monumentFoundation>CONCRETED IN GROUND</geo:monumentFoundation>
         <geo:markerDescription>STAINLESS STEEL PLATE, THREADED SPIGOT</geo:markerDescription>
         <geo:dateInstalled>2005-08-14T14:00:00Z</geo:dateInstalled>
         <geo:notes>TS 12043 (SCIMS Number)</geo:notes>
      </geo:siteIdentification>
      <geo:siteLocation>
         <geo:city>Menangle</geo:city>
         <geo:state>New South Wales</geo:state>
         <geo:countryCodeISO>AUS</geo:countryCodeISO>
         <geo:tectonicPlate codeSpace="">Australian</geo:tectonicPlate>
         <geo:approximatePositionITRF>
            <geo:xCoordinateInMeters>-4611310.099</geo:xCoordinateInMeters>
            <geo:yCoordinateInMeters>2583118.283</geo:yCoordinateInMeters>
            <geo:zCoordinateInMeters>-3558096.582</geo:zCoordinateInMeters>
            <geo:latitude-North>-34.12609992222221677593552158214151859283447265625</geo:latitude-North>
            <geo:longitude-East>150.74375258333333249538554809987545013427734375</geo:longitude-East>
            <geo:elevation-m_ellips.>111.431</geo:elevation-m_ellips.>
         </geo:approximatePositionITRF>
         <geo:notes>GDA94 coordinates (Reg 13)</geo:notes>
      </geo:siteLocation>
      <geo:gnssReceivers>
         <geo:gnssReceiver gml:id="GnssReceiverType_1702">
            <geo:manufacturerSerialNumber>356048</geo:manufacturerSerialNumber>
            <geo:receiverType codeList="codelist" codeListValue="codeListValue" codeSpace="DummyCodeSpace">LEICA GRX1200GGPRO</geo:receiverType>
            <geo:satelliteSystem>GPS+GLO</geo:satelliteSystem>
            <geo:serialNumber>356048</geo:serialNumber>
            <geo:firmwareVersion>8.10/3.019</geo:firmwareVersion>
            <geo:elevationCutoffSetting>0.0</geo:elevationCutoffSetting>
            <geo:dateInstalled>2011-03-14T23:20:00Z</geo:dateInstalled>
            <geo:dateRemoved>2012-02-02T02:30:00Z</geo:dateRemoved>
            <geo:temperatureStabilization>0.0</geo:temperatureStabilization>
         </geo:gnssReceiver>
         <geo:dateInserted>2011-03-14T23:20:00Z</geo:dateInserted>
      </geo:gnssReceivers>
      <geo:gnssReceivers>
         <geo:gnssReceiver gml:id="GnssReceiverType_1703">
            <geo:manufacturerSerialNumber>356048</geo:manufacturerSerialNumber>
            <geo:receiverType codeList="codelist" codeListValue="codeListValue" codeSpace="DummyCodeSpace">LEICA GRX1200GGPRO</geo:receiverType>
            <geo:satelliteSystem>GPS+GLO</geo:satelliteSystem>
            <geo:serialNumber>356048</geo:serialNumber>
            <geo:firmwareVersion>6.00/3.017</geo:firmwareVersion>
            <geo:elevationCutoffSetting>0.0</geo:elevationCutoffSetting>
            <geo:dateInstalled>2005-08-15T00:00:00Z</geo:dateInstalled>
            <geo:dateRemoved>2011-03-14T23:20:00Z</geo:dateRemoved>
            <geo:temperatureStabilization>0.0</geo:temperatureStabilization>
         </geo:gnssReceiver>
         <geo:dateInserted>2005-08-15T00:00:00Z</geo:dateInserted>
      </geo:gnssReceivers>
      <geo:gnssReceivers>
         <geo:gnssReceiver gml:id="GnssReceiverType_1704">
            <geo:manufacturerSerialNumber>351935</geo:manufacturerSerialNumber>
            <geo:receiverType codeList="codelist" codeListValue="codeListValue" codeSpace="DummyCodeSpace">LEICA GRX1200GGPRO</geo:receiverType>
            <geo:satelliteSystem>GPS+GLO</geo:satelliteSystem>
            <geo:serialNumber>351935</geo:serialNumber>
            <geo:firmwareVersion>8.51/3.019</geo:firmwareVersion>
            <geo:elevationCutoffSetting>0.0</geo:elevationCutoffSetting>
            <geo:dateInstalled>2013-01-18T01:22:00Z</geo:dateInstalled>
            <geo:dateRemoved></geo:dateRemoved>
            <geo:temperatureStabilization>0.0</geo:temperatureStabilization>
         </geo:gnssReceiver>
         <geo:dateInserted>2013-01-18T01:22:00Z</geo:dateInserted>
      </geo:gnssReceivers>
      <geo:gnssReceivers>
         <geo:gnssReceiver gml:id="GnssReceiverType_1705">
            <geo:manufacturerSerialNumber>356048</geo:manufacturerSerialNumber>
            <geo:receiverType codeList="codelist" codeListValue="codeListValue" codeSpace="DummyCodeSpace">LEICA GRX1200GGPRO</geo:receiverType>
            <geo:satelliteSystem>GPS+GLO</geo:satelliteSystem>
            <geo:serialNumber>356048</geo:serialNumber>
            <geo:firmwareVersion>8.50/3.019</geo:firmwareVersion>
            <geo:elevationCutoffSetting>0.0</geo:elevationCutoffSetting>
            <geo:dateInstalled>2012-02-02T02:30:00Z</geo:dateInstalled>
            <geo:dateRemoved>2013-01-18T01:22:00Z</geo:dateRemoved>
            <geo:temperatureStabilization>0.0</geo:temperatureStabilization>
         </geo:gnssReceiver>
         <geo:dateInserted>2012-02-02T02:30:00Z</geo:dateInserted>
      </geo:gnssReceivers>
      <geo:gnssAntennas>
         <geo:gnssAntenna gml:id="GnssAntennaType_740">
            <geo:manufacturerSerialNumber>CR6200323021</geo:manufacturerSerialNumber>
            <geo:antennaType codeList="codelist" codeListValue="codeListValue" codeSpace="codespace">ASH701945E_M    SCIS</geo:antennaType>
            <geo:serialNumber>CR6200323021</geo:serialNumber>
            <geo:antennaReferencePoint codeSpace="">BPA</geo:antennaReferencePoint>
            <geo:marker-arpUpEcc.>0.0</geo:marker-arpUpEcc.>
            <geo:marker-arpNorthEcc.>0.0</geo:marker-arpNorthEcc.>
            <geo:marker-arpEastEcc.>0.0</geo:marker-arpEastEcc.>
            <geo:alignmentFromTrueNorth>0.0</geo:alignmentFromTrueNorth>
            <geo:antennaRadomeType codeSpace="CodeSpaceAttr">SCIS</geo:antennaRadomeType>
            <geo:radomeSerialNumber></geo:radomeSerialNumber>
            <geo:antennaCableType>LMR400 / LMA400</geo:antennaCableType>
            <geo:antennaCableLength>7.03</geo:antennaCableLength>
            <geo:dateInstalled>2005-08-15T00:00:00Z</geo:dateInstalled>
            <geo:dateRemoved></geo:dateRemoved>
            <geo:notes>Surge Protection (Polyphaser DGXZ+15NFNF-A) installed at receiver end.</geo:notes>
         </geo:gnssAntenna>
         <geo:dateInserted>2005-08-15T00:00:00Z</geo:dateInserted>
      </geo:gnssAntennas>
      <geo:frequencyStandards>
         <geo:frequencyStandard gml:id="FrequencyStandardType_592">
            <geo:standardType codeSpace="">INTERNAL</geo:standardType>
            <geo:inputFrequency>0.0</geo:inputFrequency>
            <gml:validTime>
               <gml:TimeInstant gml:id="TimeInstantType_494">
                  <gml:timePosition>1970-01-22T13:00:00Z</gml:timePosition>
               </gml:TimeInstant>
            </gml:validTime>
         </geo:frequencyStandard>
         <geo:dateInserted>2016-04-14T00:03:10Z</geo:dateInserted>
      </geo:frequencyStandards>
      <geo:siteContact gml:id="AgencyPropertyType_730">
         <gmd:MD_SecurityConstraints id="MDSecurityConstraintsType_730">
            <gmd:classification>
               <gmd:MD_ClassificationCode codeList="codelist" codeListValue="codeListValue"/>
            </gmd:classification>
         </gmd:MD_SecurityConstraints>
         <gmd:CI_ResponsibleParty id="CIResponsiblePartyType_730">
            <gmd:individualName>
               <gco:CharacterString>Simon McElroy</gco:CharacterString>
            </gmd:individualName>
            <gmd:organisationName>
               <gco:CharacterString>NSW Land and Property Information</gco:CharacterString>
            </gmd:organisationName>
            <gmd:contactInfo>
               <gmd:CI_Contact id="CIContactType_730">
                  <gmd:phone>
                     <gmd:CI_Telephone id="CITelephoneType_283">
                        <gmd:voice>
                           <gco:CharacterString>+61 2 6332 8300</gco:CharacterString>
                        </gmd:voice>
                     </gmd:CI_Telephone>
                  </gmd:phone>
                  <gmd:address>
                     <gmd:CI_Address id="CIAddressType_730">
                        <gmd:deliveryPoint>
                           <gco:CharacterString>346 Panorama Avenue</gco:CharacterString>
                        </gmd:deliveryPoint>
                        <gmd:electronicMailAddress>
                           <gco:CharacterString>Simon.McElroy@lpi.nsw.gov.au</gco:CharacterString>
                        </gmd:electronicMailAddress>
                     </gmd:CI_Address>
                  </gmd:address>
               </gmd:CI_Contact>
            </gmd:contactInfo>
            <gmd:role>
               <gmd:CI_RoleCode codeList="codelist" codeListValue="codeListValue"/>
            </gmd:role>
         </gmd:CI_ResponsibleParty>
      </geo:siteContact>
      <geo:siteMetadataCustodian gml:id="AgencyPropertyType_731">
         <gmd:MD_SecurityConstraints id="MDSecurityConstraintsType_731">
            <gmd:classification>
               <gmd:MD_ClassificationCode codeList="codelist" codeListValue="codeListValue"/>
            </gmd:classification>
         </gmd:MD_SecurityConstraints>
         <gmd:CI_ResponsibleParty id="CIResponsiblePartyType_731">
            <gmd:organisationName>
               <gco:CharacterString>NSW Land and Property Information</gco:CharacterString>
            </gmd:organisationName>
            <gmd:contactInfo>
               <gmd:CI_Contact id="CIContactType_731">
                  <gmd:address>
                     <gmd:CI_Address id="CIAddressType_731"/>
                  </gmd:address>
               </gmd:CI_Contact>
            </gmd:contactInfo>
            <gmd:role>
               <gmd:CI_RoleCode codeList="codelist" codeListValue="codeListValue"/>
            </gmd:role>
         </gmd:CI_ResponsibleParty>
      </geo:siteMetadataCustodian>
      <geo:moreInformation>
         <geo:dataCenter>http</geo:dataCenter>
         <geo:dataCenter>http</geo:dataCenter>
         <geo:urlForMoreInformation>http</geo:urlForMoreInformation>
         <geo:siteMap></geo:siteMap>
         <geo:siteDiagram></geo:siteDiagram>
         <geo:horizonMask></geo:horizonMask>
         <geo:monumentDescription></geo:monumentDescription>
         <geo:sitePictures></geo:sitePictures>
         <geo:antennaGraphicsWithDimensions></geo:antennaGraphicsWithDimensions>
         <geo:insertTextGraphicFromAntenna></geo:insertTextGraphicFromAntenna>
         <geo:DOI codeSpace="CodeSpaceTODO">CodeTypeTODO</geo:DOI>
      </geo:moreInformation>
   </geo:siteLog>
</geo:GeodesyML>


text:
$configFile = Join-Path $env:chocolateyPackageFolder 'config.xml'
$config = Import-CliXml $configFile

Remove-Item $config.destination -Recurse -Force

$PathToRemove = $config.destination
foreach ($path in [Environment]::GetEnvironmentVariable("PATH", "User").split(';'))
{
  If ($Path)
  {
    If (($path -ine "$PathToRemove") -AND ($path -ine "$PathToRemove\"))
    {
      [string[]]$Newpath += "$path"
    }
  }
}
$AssembledNewPath = ($newpath -join(';')).trimend(';')

[Environment]::SetEnvironmentVariable("PATH",$AssembledNewPath, "User")


text:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.michael.doubanonline"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-permission android:name = "android.permission.INTERNET"/>
    <uses-permission android:name = "android.permission.ACCESS_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.VIBRATE" />

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="21" />

    <application
        android:name=".MyApplication"
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/Theme.Sherlock" >

        <activity
            android:name=".SplashActivity"
            android:screenOrientation="portrait"
            android:label="@string/app_name"
            android:theme="@android:style/Theme.Black.NoTitleBar" >
            <intent-filter >
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <activity android:name=".MainActivity" android:theme="@style/Theme.Sherlock.Light.DarkActionBar"/>
        <activity android:name="com.michael.doubanonline.OnlineDetailActivity" android:theme="@style/Theme.Sherlock.Light.DarkActionBar"/>
        <activity android:name="com.michael.doubanonline.PhotoDetailActivity" android:theme="@style/Theme.Sherlock.Light.DarkActionBar"/>
        <activity android:name="com.michael.doubanonline.AboutActivity" android:theme="@style/activity_dialog"/><!-- @style/Theme.Sherlock.Dialog 过期了 -->
        <activity android:name="com.michael.doubanonline.CertificationActivity" android:theme="@style/Theme.Sherlock.Light.DarkActionBar"/>
        <activity android:name="com.michael.doubanonline.WebViewActivity" android:theme="@style/Theme.Sherlock.Light.DarkActionBar"/>

    </application>

</manifest>


text:
<!-- Copyright 2015 The Chromium Authors. All rights reserved.
     Use of this source code is governed by a BSD-style license that can be
     found in the LICENSE file.
-->

<!--
navbar.md has to be in the root of a repo.
For documentation on format, see
https://gerrit.googlesource.com/gitiles/+/master/Documentation/markdown.md#Navigation-bar
-->

# Catapult

* [Home](/README.md)
* [Dashboard](/dashboard/README.md)
* [Telemetry](/telemetry/README.md)
* [Tracing](/tracing/README.md)

[home]: /README.md
[logo]: /tracing/images/third-trace-viewer-circle-blue.png


text:
namespace Lag {
    class ICursorListener {
    public:
        virtual ~ICursorListener() = default;

        virtual void onCursorMove(int x, int y) = 0;
        virtual void onButtonPressed(int x, int y, int button, int modifiers) = 0;
        virtual void onButtonReleased(int x, int y, int button, int modifiers) = 0;
    };
}


text:
require 'stringio'
require_relative '../../spec_helper'

describe "StringIO#internal_encoding" do
  it "returns nil" do
    io = StringIO.new
    io.set_encoding Encoding::UTF_8
    io.internal_encoding.should == nil
  end
end


text:
<?php

namespace Symfony\Component\Routing\Loader;

use Symfony\Component\Config\Loader\FileLoader;
use Symfony\Component\Config\Resource\FileResource;
use Symfony\Component\Config\Util\XmlUtils;
use Symfony\Component\Routing\Loader\Configurator\Traits\HostTrait;
use Symfony\Component\Routing\Loader\Configurator\Traits\LocalizedRouteTrait;
use Symfony\Component\Routing\Loader\Configurator\Traits\PrefixTrait;
use Symfony\Component\Routing\RouteCollection;

/**
 * XmlFileLoader loads XML routing files.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 * @author Tobias Schultze <http://tobion.de>
 */
class XmlFileLoader extends FileLoader
{
    use HostTrait;
    use LocalizedRouteTrait;
    use PrefixTrait;

    const NAMESPACE_URI = 'http://symfony.com/schema/routing';
    const SCHEME_PATH = '/schema/routing/routing-1.0.xsd';

    /**
     * Loads an XML file.
     *
     * @param string      $file An XML file path
     * @param string|null $type The resource type
     *
     * @return RouteCollection A RouteCollection instance
     *
     * @throws \InvalidArgumentException when the file cannot be loaded or when the XML cannot be
     *                                   parsed because it does not validate against the scheme
     */
    public function load($file, string $type = null)
    {
        $path = $this->locator->locate($file);

        $xml = $this->loadFile($path);

        $collection = new RouteCollection();
        $collection->addResource(new FileResource($path));

        // process routes and imports
        foreach ($xml->documentElement->childNodes as $node) {
            if (!$node instanceof \DOMElement) {
                continue;
            }

            $this->parseNode($collection, $node, $path, $file);
        }

        return $collection;
    }

    /**
     * Parses a node from a loaded XML file.
     *
     * @param \DOMElement $node Element to parse
     * @param string      $path Full path of the XML file being processed
     * @param string      $file Loaded file name
     *
     * @throws \InvalidArgumentException When the XML is invalid
     */
    protected function parseNode(RouteCollection $collection, \DOMElement $node, string $path, string $file)
    {
        if (self::NAMESPACE_URI !== $node->namespaceURI) {
            return;
        }

        switch ($node->localName) {
            case 'route':
                $this->parseRoute($collection, $node, $path);
                break;
            case 'import':
                $this->parseImport($collection, $node, $path, $file);
                break;
            default:
                throw new \InvalidArgumentException(sprintf('Unknown tag "%s" used in file "%s". Expected "route" or "import".', $node->localName, $path));
        }
    }

    /**
     * {@inheritdoc}
     */
    public function supports($resource, string $type = null)
    {
        return \is_string($resource) && 'xml' === pathinfo($resource, PATHINFO_EXTENSION) && (!$type || 'xml' === $type);
    }

    /**
     * Parses a route and adds it to the RouteCollection.
     *
     * @param \DOMElement $node Element to parse that represents a Route
     * @param string      $path Full path of the XML file being processed
     *
     * @throws \InvalidArgumentException When the XML is invalid
     */
    protected function parseRoute(RouteCollection $collection, \DOMElement $node, string $path)
    {
        if ('' === $id = $node->getAttribute('id')) {
            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must have an "id" attribute.', $path));
        }

        $schemes = preg_split('/[\s,\|]++/', $node->getAttribute('schemes'), -1, PREG_SPLIT_NO_EMPTY);
        $methods = preg_split('/[\s,\|]++/', $node->getAttribute('methods'), -1, PREG_SPLIT_NO_EMPTY);

        list($defaults, $requirements, $options, $condition, $paths, /* $prefixes */, $hosts) = $this->parseConfigs($node, $path);

        if (!$paths && '' === $node->getAttribute('path')) {
            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must have a "path" attribute or <path> child nodes.', $path));
        }

        if ($paths && '' !== $node->getAttribute('path')) {
            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must not have both a "path" attribute and <path> child nodes.', $path));
        }

        $routes = $this->createLocalizedRoute($collection, $id, $paths ?: $node->getAttribute('path'));
        $routes->addDefaults($defaults);
        $routes->addRequirements($requirements);
        $routes->addOptions($options);
        $routes->setSchemes($schemes);
        $routes->setMethods($methods);
        $routes->setCondition($condition);

        if (null !== $hosts) {
            $this->addHost($routes, $hosts);
        }
    }

    /**
     * Parses an import and adds the routes in the resource to the RouteCollection.
     *
     * @param \DOMElement $node Element to parse that represents a Route
     * @param string      $path Full path of the XML file being processed
     * @param string      $file Loaded file name
     *
     * @throws \InvalidArgumentException When the XML is invalid
     */
    protected function parseImport(RouteCollection $collection, \DOMElement $node, string $path, string $file)
    {
        if ('' === $resource = $node->getAttribute('resource')) {
            throw new \InvalidArgumentException(sprintf('The <import> element in file "%s" must have a "resource" attribute.', $path));
        }

        $type = $node->getAttribute('type');
        $prefix = $node->getAttribute('prefix');
        $schemes = $node->hasAttribute('schemes') ? preg_split('/[\s,\|]++/', $node->getAttribute('schemes'), -1, PREG_SPLIT_NO_EMPTY) : null;
        $methods = $node->hasAttribute('methods') ? preg_split('/[\s,\|]++/', $node->getAttribute('methods'), -1, PREG_SPLIT_NO_EMPTY) : null;
        $trailingSlashOnRoot = $node->hasAttribute('trailing-slash-on-root') ? XmlUtils::phpize($node->getAttribute('trailing-slash-on-root')) : true;
        $namePrefix = $node->getAttribute('name-prefix') ?: null;

        list($defaults, $requirements, $options, $condition, /* $paths */, $prefixes, $hosts) = $this->parseConfigs($node, $path);

        if ('' !== $prefix && $prefixes) {
            throw new \InvalidArgumentException(sprintf('The <route> element in file "%s" must not have both a "prefix" attribute and <prefix> child nodes.', $path));
        }

        $exclude = [];
        foreach ($node->childNodes as $child) {
            if ($child instanceof \DOMElement && $child->localName === $exclude && self::NAMESPACE_URI === $child->namespaceURI) {
                $exclude[] = $child->nodeValue;
            }
        }

        if ($node->hasAttribute('exclude')) {
            if ($exclude) {
                throw new \InvalidArgumentException('You cannot use both the attribute "exclude" and <exclude> tags at the same time.');
            }
            $exclude = [$node->getAttribute('exclude')];
        }

        $this->setCurrentDir(\dirname($path));

        /** @var RouteCollection[] $imported */
        $imported = $this->import($resource, ('' !== $type ? $type : null), false, $file, $exclude) ?: [];

        if (!\is_array($imported)) {
            $imported = [$imported];
        }

        foreach ($imported as $subCollection) {
            $this->addPrefix($subCollection, $prefixes ?: $prefix, $trailingSlashOnRoot);

            if (null !== $hosts) {
                $this->addHost($subCollection, $hosts);
            }

            if (null !== $condition) {
                $subCollection->setCondition($condition);
            }
            if (null !== $schemes) {
                $subCollection->setSchemes($schemes);
            }
            if (null !== $methods) {
                $subCollection->setMethods($methods);
            }
            if (null !== $namePrefix) {
                $subCollection->addNamePrefix($namePrefix);
            }
            $subCollection->addDefaults($defaults);
            $subCollection->addRequirements($requirements);
            $subCollection->addOptions($options);

            $collection->addCollection($subCollection);
        }
    }

    /**
     * Loads an XML file.
     *
     * @param string $file An XML file path
     *
     * @return \DOMDocument
     *
     * @throws \InvalidArgumentException When loading of XML file fails because of syntax errors
     *                                   or when the XML structure is not as expected by the scheme -
     *                                   see validate()
     */
    protected function loadFile(string $file)
    {
        return XmlUtils::loadFile($file, __DIR__.static::SCHEME_PATH);
    }

    /**
     * Parses the config elements (default, requirement, option).
     *
     * @throws \InvalidArgumentException When the XML is invalid
     */
    private function parseConfigs(\DOMElement $node, string $path): array
    {
        $defaults = [];
        $requirements = [];
        $options = [];
        $condition = null;
        $prefixes = [];
        $paths = [];
        $hosts = [];

        /** @var \DOMElement $n */
        foreach ($node->getElementsByTagNameNS(self::NAMESPACE_URI, '*') as $n) {
            if ($node !== $n->parentNode) {
                continue;
            }

            switch ($n->localName) {
                case 'path':
                    $paths[$n->getAttribute('locale')] = trim($n->textContent);
                    break;
                case 'host':
                    $hosts[$n->getAttribute('locale')] = trim($n->textContent);
                    break;
                case 'prefix':
                    $prefixes[$n->getAttribute('locale')] = trim($n->textContent);
                    break;
                case 'default':
                    if ($this->isElementValueNull($n)) {
                        $defaults[$n->getAttribute('key')] = null;
                    } else {
                        $defaults[$n->getAttribute('key')] = $this->parseDefaultsConfig($n, $path);
                    }

                    break;
                case 'requirement':
                    $requirements[$n->getAttribute('key')] = trim($n->textContent);
                    break;
                case 'option':
                    $options[$n->getAttribute('key')] = XmlUtils::phpize(trim($n->textContent));
                    break;
                case 'condition':
                    $condition = trim($n->textContent);
                    break;
                default:
                    throw new \InvalidArgumentException(sprintf('Unknown tag "%s" used in file "%s". Expected "default", "requirement", "option" or "condition".', $n->localName, $path));
            }
        }

        if ($controller = $node->getAttribute('controller')) {
            if (isset($defaults['_controller'])) {
                $name = $node->hasAttribute('id') ? sprintf('"%s".', $node->getAttribute('id')) : sprintf('the "%s" tag.', $node->tagName);

                throw new \InvalidArgumentException(sprintf('The routing file "%s" must not specify both the "controller" attribute and the defaults key "_controller" for ', $path).$name);
            }

            $defaults['_controller'] = $controller;
        }
        if ($node->hasAttribute('locale')) {
            $defaults['_locale'] = $node->getAttribute('locale');
        }
        if ($node->hasAttribute('format')) {
            $defaults['_format'] = $node->getAttribute('format');
        }
        if ($node->hasAttribute('utf8')) {
            $options['utf8'] = XmlUtils::phpize($node->getAttribute('utf8'));
        }
        if ($stateless = $node->getAttribute('stateless')) {
            if (isset($defaults['_stateless'])) {
                $name = $node->hasAttribute('id') ? sprintf('"%s".', $node->getAttribute('id')) : sprintf('the "%s" tag.', $node->tagName);

                throw new \InvalidArgumentException(sprintf('The routing file "%s" must not specify both the "stateless" attribute and the defaults key "_stateless" for ', $path).$name);
            }

            $defaults['_stateless'] = XmlUtils::phpize($stateless);
        }

        if (!$hosts) {
            $hosts = $node->hasAttribute('host') ? $node->getAttribute('host') : null;
        }

        return [$defaults, $requirements, $options, $condition, $paths, $prefixes, $hosts];
    }

    /**
     * Parses the "default" elements.
     *
     * @return array|bool|float|int|string|null The parsed value of the "default" element
     */
    private function parseDefaultsConfig(\DOMElement $element, string $path)
    {
        if ($this->isElementValueNull($element)) {
            return null;
        }

        // Check for existing element nodes in the default element. There can
        // only be a single element inside a default element. So this element
        // (if one was found) can safely be returned.
        foreach ($element->childNodes as $child) {
            if (!$child instanceof \DOMElement) {
                continue;
            }

            if (self::NAMESPACE_URI !== $child->namespaceURI) {
                continue;
            }

            return $this->parseDefaultNode($child, $path);
        }

        // If the default element doesn't contain a nested "bool", "int", "float",
        // "string", "list", or "map" element, the element contents will be treated
        // as the string value of the associated default option.
        return trim($element->textContent);
    }

    /**
     * Recursively parses the value of a "default" element.
     *
     * @return array|bool|float|int|string The parsed value
     *
     * @throws \InvalidArgumentException when the XML is invalid
     */
    private function parseDefaultNode(\DOMElement $node, string $path)
    {
        if ($this->isElementValueNull($node)) {
            return null;
        }

        switch ($node->localName) {
            case 'bool':
                return 'true' === trim($node->nodeValue) || '1' === trim($node->nodeValue);
            case 'int':
                return (int) trim($node->nodeValue);
            case 'float':
                return (float) trim($node->nodeValue);
            case 'string':
                return trim($node->nodeValue);
            case 'list':
                $list = [];

                foreach ($node->childNodes as $element) {
                    if (!$element instanceof \DOMElement) {
                        continue;
                    }

                    if (self::NAMESPACE_URI !== $element->namespaceURI) {
                        continue;
                    }

                    $list[] = $this->parseDefaultNode($element, $path);
                }

                return $list;
            case 'map':
                $map = [];

                foreach ($node->childNodes as $element) {
                    if (!$element instanceof \DOMElement) {
                        continue;
                    }

                    if (self::NAMESPACE_URI !== $element->namespaceURI) {
                        continue;
                    }

                    $map[$element->getAttribute('key')] = $this->parseDefaultNode($element, $path);
                }

                return $map;
            default:
                throw new \InvalidArgumentException(sprintf('Unknown tag "%s" used in file "%s". Expected "bool", "int", "float", "string", "list", or "map".', $node->localName, $path));
        }
    }

    private function isElementValueNull(\DOMElement $element): bool
    {
        $namespaceUri = 'http://www.w3.org/2001/XMLSchema-instance';

        if (!$element->hasAttributeNS($namespaceUri, 'nil')) {
            return false;
        }

        return 'true' === $element->getAttributeNS($namespaceUri, 'nil') || '1' === $element->getAttributeNS($namespaceUri, 'nil');
    }
}


text:
"""
    riddles.views
    ~~~~~~~~~~~~~~

    riddles views file

    :copyright: (c) 2012 by arruda.
"""
from django.shortcuts import get_object_or_404
from django.contrib.auth.decorators import login_required

from annoying.decorators import render_to


text:
/**
 * The handler for Spotify Route access.
 */
module.exports = {
    handlers: () => {
        // credentials are optional
        const spotifyCallback = (req, res, next) => {
            console.log(req);
        };
        return {
            spotifyCallback
        };
    }
};


text:
#ifndef OMG_DDS_TOPIC_TOPIC_DESCRIPTION_HPP_
#define OMG_DDS_TOPIC_TOPIC_DESCRIPTION_HPP_

#include <dds/topic/detail/TopicDescription.hpp>

namespace dds
{
namespace topic
{
template < typename T,
           template <typename Q> class DELEGATE = dds::topic::detail::TopicDescription >
class TopicDescription;
}
}

/**
 * @todo RTF Issue - moved include
 * @note This include was moved here as MSVC appears to ignore any
 * attempt to 're-declare' a template class with a default argument like:
 * dds/topic/detail/AnyTopicDescription.hpp(48): error C2976: 'dds::topic::TopicDescription' : too few template arguments
 * dds/topic/TTopicDescription.hpp(41) : see declaration of 'dds::topic::TopicDescription'
 */
#include <dds/topic/TTopicDescription.hpp>

#endif /* OMG_DDS_TOPIC_TOPIC_DESCRIPTION_HPP_ */


text:
package org.geometerplus.android.fbreader.network.action;

import android.app.Activity;

import org.geometerplus.fbreader.network.*;
import org.geometerplus.fbreader.network.tree.NetworkCatalogRootTree;

public class DisableCatalogAction extends Action {
	public DisableCatalogAction(Activity activity) {
		super(activity, ActionCode.DISABLE_CATALOG, "disableCatalog", -1);
	}

	@Override
	public boolean isVisible(NetworkTree tree) {
		return
			tree instanceof NetworkCatalogRootTree &&
			tree.getLink().getType() != INetworkLink.Type.Sync;
	}

	@Override
	public void run(NetworkTree tree) {
		myLibrary.setLinkActive(tree.getLink(), false);
		myLibrary.synchronize();
		// TODO: invalidate view
	}
}