text:
package roboticshours;

import java.awt.Component;
import java.awt.Container;
import java.awt.FocusTraversalPolicy;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import javax.swing.GroupLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPasswordField;
import javax.swing.JTextField;
import javax.swing.LayoutStyle;
import javax.swing.WindowConstants;

/**
 * A JFrame to handle login, authentication, and decryption operations.
 * This will be the first thing the user sees.
 * This screen is a basic login screen visually,
 * with a username field, password field, and a login button.
 * The complexity of this screen comes in the authentication logic.
 *
 * @author Alan
 */
public class LoginScreen extends JFrame implements KeyListener { //LoginScreen is a JFrame that also has a KeyListener listening for VK_ENTER.

    private JTextField usernameField;
    private JPasswordField passwordField;
    private JButton loginButton;

    private static CustomFocusTraversalPolicy policy; //Declares a FocusTraversalPolicy that defines the order in which focus is passed within the JFrame login screen.

    /**
     *  Initializes the components in the LoginScreen.
     */
    public LoginScreen() {
        initComponents();//The constructor creates the JFrame.
    }

    private void initComponents() {

        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        JLabel usernameLabel = new JLabel();    //Creates a JLabel usernameLabel
        usernameLabel.setText("Username");      //Sets the text on the JLabel to "Username".
        usernameLabel.setFocusable(false);      //Prevents program from focusing on the labels. Probably unnecesary, considering the CustomFocusTraversalPolicy

        JLabel passwordLabel = new JLabel();    //Creates a JLabel passwordLabel
        passwordLabel.setText("Password");
        passwordLabel.setFocusable(false);

        usernameField = new JTextField();

        passwordField = new JPasswordField(){
            @Override
            public void paste(){}
        };
        passwordField.addKeyListener(this); //KeyListener allows VK_ENTER to "press" the login button

        loginButton = new JButton();
        loginButton.setText("Login");
        loginButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent evt) {
                loginButtonActionPerformed(evt);
            }
        });
        loginButton.addKeyListener(this);

        ArrayList<Component> order = new ArrayList<>(3); //Setting the order of components for IRRITATING FocusTraversalPolicy
        order.add(usernameField);
        order.add(passwordField);
        order.add(loginButton);

        policy = new CustomFocusTraversalPolicy(order);//construct the FocusTraversalPolicy
        this.setFocusTraversalPolicy(policy); //Actually set the FocusTraversalPolicy

	/*<NetBeans Generated Layout Code>*/

        GroupLayout layout = new GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
                    .addComponent(passwordLabel)
                    .addComponent(usernameLabel))
                .addPreferredGap(LayoutStyle.ComponentPlacement.UNRELATED)
                .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING, false)
                    .addComponent(passwordField, GroupLayout.DEFAULT_SIZE, 111, Short.MAX_VALUE)
                    .addComponent(usernameField))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(loginButton)
                .addContainerGap(GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                    .addComponent(usernameLabel)
                    .addComponent(usernameField, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
                .addPreferredGap(LayoutStyle.ComponentPlacement.UNRELATED)
                .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                    .addComponent(passwordLabel)
                    .addComponent(passwordField, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE))
                .addContainerGap(GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
            .addGroup(GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addContainerGap(GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addComponent(loginButton)
                .addGap(25, 25, 25))
        );

        /*<End NetBeans Generated Layout Code>*/

        pack();
    }

   private void loginButtonActionPerformed(ActionEvent evt) { //This describes the actions that are taken when the login button or any of its aliases are pressed, e.g. the process of logging in.

        ArrayList<byte[]> authList = new ArrayList<>(); //ArrayList of byte arrays from the files
        File[] fileList = new File("data").listFiles(); //Array of Files

        Arrays.sort(fileList); //Ensuring 01, 02 ... order

        for(File f : fileList){
            try (Scanner cs = new Scanner(f)){
                String arrayRepresentation = cs.nextLine(); //Get the first line; it's the key bytes.
                String[] byteStrings = arrayRepresentation.substring(1, arrayRepresentation.length() - 1).split(", "); //Extract all but character 0 and last
                byte[] authBytes = new byte[byteStrings.length]; //Make a new array as long as the array of strings
                for(int i = 0; i < authBytes.length; i++){ //For the length of the array,
                    authBytes[i] = (byte)Integer.parseInt(byteStrings[i]); //Parse the byte into authBytes.
                }
                authList.add(authBytes); //Finally, add authBytes to the list.
            }
            catch (FileNotFoundException ex) {
                System.out.println("File not found for iterator loginButtonActionPerformed.");
            }
        } //Now the Credential List is full of credentials. byte[]

        byte[] username = usernameField.getText().replace(" ", "+").getBytes();
        byte[] password = Encryptor.charToByte(passwordField.getPassword()); //Get Credential's components from login screen's username/password fields.
        passwordField.setText(null); //Clearing the password field.

        byte[] credentials = new byte[username.length + password.length]; //Creating a combined credential array that is the length of username + password
        System.arraycopy(username, 0, credentials, 0, username.length); //Copying from username at 0 to credentials at 0 for all bytes in username.
        System.arraycopy(password, 0, credentials, username.length, password.length); //Copying from password at 0 to credentials at end of username for all bytes in password.

        Arrays.fill(username, (byte)0); //Clear username

        Arrays.fill(password, (byte)0); //Clear password

        byte[] hashedCredentials = Encryptor.hash(credentials, 1024); //Hashes the byte representation of credentials using static salt and 1024 iterations.

        Arrays.fill(credentials, (byte)0); //Clear credentials

        boolean validCredentials = false; //Prep for authentication
        boolean admin = false; //This is a dangerous value.
        File file = null; //Selected file

        byte[] adminCredentials = {94, -54, -46, 102, 5, -78, 70, -20, 41, -61, -40, -120, -42, -117, 81, -109, 77, 7, -123, 35, -7, 18, 26, 114, -21, -107, -105, 93, -5, -4, -119, 92};
        //Administrator/Robotics1 NB: Admin credentials for dev only. Change before push to prod
        if(Arrays.equals(hashedCredentials, adminCredentials)){ //SO DANGEROUS
            admin = true; //(!!!)
        }
        else{
            for(byte[] b : authList){
                if(Arrays.equals(b, hashedCredentials)){ //If the selected byte[] from authList matches the byte[] hashedcredentials...
                    validCredentials = true; //Yay, valid login
                    file = fileList[authList.indexOf(b)]; //Sets file equal to file at the index of the matching credential from credentialList
                }
            }
        }
        if(admin){
            ImportExport.importAll();
            Run.hideLoginScreen();
            java.awt.EventQueue.invokeLater(new Runnable() {
                @Override
                public void run() {
                    new AdminScreen().setVisible(true);
                }
            });
        }
        else if(validCredentials){ //IF valid login
            Encryptor.makeKey(hashedCredentials);
            ImportExport.importSingleFile(file);
            final int ID = Integer.parseInt(file.getName().replaceAll("[^0-9]", ""));
            Run.hideLoginScreen();
            java.awt.EventQueue.invokeLater(new Runnable() {
                @Override
                public void run() {
                    new MainScreen(Run.getAccount(ID)).setVisible(true);
                }
            });
        }
        else{
            passwordField.setText("");
            JOptionPane.showMessageDialog(rootPane, "Invalid Username or Password!\nUsername and Password are case-sensitive.", "Error", JOptionPane.ERROR_MESSAGE);
        }
    }

    /**
     *
     * @param ke
     */
    @Override
    public void keyTyped(KeyEvent ke) {} //On key typed, do nothing.

    /**
     *
     * @param ke
     */
    @Override
    public void keyReleased(KeyEvent ke) {} //On ley released, do nothing.

    /**
     *
     * @param ke
     */
    @Override
    public void keyPressed(KeyEvent ke) { //On key pressed, if key pressed is enter key, send login button action performed
        if(ke.getKeyCode() == KeyEvent.VK_ENTER){
            loginButtonActionPerformed(null);
        }
    }

    /**
     *  Creates a FocusTraversalPolicy to define the order in which tab inputs shift focus.
     */
    public static class CustomFocusTraversalPolicy extends FocusTraversalPolicy //Making a focus traversal policy to fix the tab order
    {
        ArrayList<Component> order;

        /**
         *
         * @param o
         */
        public CustomFocusTraversalPolicy(ArrayList<Component> o) {
            order = (ArrayList<Component>)o.clone(); //Sets order equal to the arrayList of components supplied
        }

        /**
         *
         * @param focusCycleRoot
         * @param aComponent
         * @return
         */
        @Override
        public Component getComponentAfter(Container focusCycleRoot, Component aComponent){
            return order.indexOf(aComponent) == 2 ? order.get(0) : order.get(order.indexOf(aComponent) + 1); //If component index is 2, get at index 0 otherwise get at index + 1
        }

        /**
         *
         * @param focusCycleRoot
         * @param aComponent
         * @return
         */
        @Override
        public Component getComponentBefore(Container focusCycleRoot, Component aComponent){
            return order.indexOf(aComponent) == 0 ? order.get(2) : order.get(order.indexOf(aComponent) - 1); //If component index is 0, get at index 2 otherwise get at index - 1
        }

        /**
         *
         * @param focusCycleRoot
         * @return
         */
        @Override
        public Component getDefaultComponent(Container focusCycleRoot) {
            return order.get(0); //Default component is usernameField
        }

        /**
         *
         * @param focusCycleRoot
         * @return
         */
        @Override
        public Component getLastComponent(Container focusCycleRoot) {
            return order.get(2); //Last component is loginButton
        }

        /**
         *
         * @param focusCycleRoot
         * @return
         */
        @Override
        public Component getFirstComponent(Container focusCycleRoot) {
            return order.get(0); //First component is usernameField
        }
    }
}


text:
package com.sequenceiq.cloudbreak.common.event;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.sequenceiq.cloudbreak.eventbus.Promise;

public interface Acceptable extends Payload {
    @JsonIgnore
    Promise<AcceptResult> accepted();
}

redpajama_set_name: RedPajamaGithub


text:
namespace More.Globalization
{
    using System;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Diagnostics;
    using System.Diagnostics.Contracts;
    using System.Linq;
    using static System.DateTime;
    using static System.Globalization.CultureInfo;
    using static System.Math;

    /// <summary>
    /// Represents a fiscal month.
    /// </summary>
    [DebuggerDisplay( "FirstDay = {FirstDay}, LastDay = {LastDay}" )]
    public class FiscalMonth
    {
        readonly Collection<FiscalWeek> weeks = new Collection<FiscalWeek>();

        /// <summary>
        /// Initializes a new instance of the <see cref="FiscalMonth"/> class.
        /// </summary>
        public FiscalMonth() { }

        /// <summary>
        /// Initializes a new instance of the <see cref="FiscalMonth"/> class.
        /// </summary>
        /// <param name="weeks">The <see cref="IEnumerable{T}">sequence</see> of <see cref="FiscalWeek">weeks</see>
        /// to initialize the month with.</param>
        public FiscalMonth( IEnumerable<FiscalWeek> weeks )
        {
            Arg.NotNull( weeks, nameof( weeks ) );
            this.weeks.AddRange( weeks );
        }

        /// <summary>
        /// Gets the first day of the fiscal month.
        /// </summary>
        /// <value>A <see cref="DateTime"/> structure.</value>
        public DateTime FirstDay => Weeks.FirstOrDefault()?.FirstDay ?? Today;

        /// <summary>
        /// Gets the last day of the fiscal month.
        /// </summary>
        /// <value>A <see cref="DateTime"/> structure.</value>
        public DateTime LastDay => Weeks.LastOrDefault()?.LastDay ?? Today;

        /// <summary>
        /// Gets the number of days in the fiscal month.
        /// </summary>
        /// <value>The number of days in the fiscal month.</value>
        public int DaysInMonth
        {
            get
            {
                Contract.Ensures( Contract.Result<int>() >= 0 );
                return ( (int) Floor( LastDay.Subtract( FirstDay ).TotalDays ) ) + 1;
            }
        }

        /// <summary>
        /// Gets the fiscal weeks in the fiscal month.
        /// </summary>
        /// <value>An <see cref="IList{T}"/> object.</value>
        public virtual IList<FiscalWeek> Weeks
        {
            get
            {
                Contract.Ensures( Contract.Result<IList<FiscalWeek>>() != null );
                return weeks;
            }
        }

        /// <summary>
        /// Returns the string equivalent of the current instance.
        /// </summary>
        /// <returns>A <see cref="string"/> object.</returns>
        public override string ToString() =>
            string.Format( CurrentCulture, "FirstDay = {0:d}, LastDay = {1:d}", FirstDay, LastDay );
    }
}


text:
<bill session="115" type="h" number="636" updated="2017-07-20T16:56:13Z">
  <state datetime="2017-01-24">REFERRED</state>
  <status>
    <introduced datetime="2017-01-24"/>
  </status>
  <introduced datetime="2017-01-24"/>
  <titles>
    <title type="short" as="introduced">Fairness in Taxation Act of 2017</title>
    <title type="short" as="introduced">Fairness in Taxation Act of 2017</title>
    <title type="official" as="introduced">To amend the Internal Revenue Code of 1986 to impose increased rates of tax with respect to taxpayers with more than $1,000,000 taxable income, and for other purposes.</title>
    <title type="display">Fairness in Taxation Act of 2017</title>
  </titles>
  <sponsor bioguide_id="S001145"/>
  <cosponsors>
    <cosponsor bioguide_id="C001068" joined="2017-01-24"/>
    <cosponsor bioguide_id="C000714" joined="2017-01-24"/>
    <cosponsor bioguide_id="C000984" joined="2017-01-24"/>
    <cosponsor bioguide_id="D000216" joined="2017-01-24"/>
    <cosponsor bioguide_id="E000288" joined="2017-01-24"/>
    <cosponsor bioguide_id="G000551" joined="2017-01-24"/>
    <cosponsor bioguide_id="L000551" joined="2017-01-24"/>
    <cosponsor bioguide_id="N000002" joined="2017-01-24"/>
    <cosponsor bioguide_id="N000147" joined="2017-01-24"/>
    <cosponsor bioguide_id="P000607" joined="2017-01-24"/>
    <cosponsor bioguide_id="S000248" joined="2017-01-24"/>
  </cosponsors>
  <actions>
    <action datetime="2017-01-24">
      <text>Introduced in House</text>
    </action>
    <action datetime="2017-01-24" state="REFERRED">
      <text>Referred to the House Committee on Ways and Means.</text>
    </action>
  </actions>
  <committees>
    <committee subcommittee="" code="HSWM" name="House Ways and Means" activity="Referral"/>
  </committees>
  <relatedbills/>
  <subjects>
    <term name="Taxation"/>
    <term name="Capital gains tax"/>
    <term name="Income tax rates"/>
  </subjects>
  <amendments/>
  <summary date="2017-01-24T05:00:00Z" status="Introduced in House">Fairness in Taxation Act of 2017

This bill amends the Internal Revenue Code to: (1) increase individual income tax rates for taxpayers whose taxable income exceeds $1 million, and (2) provide for an adjustment in the capital gains tax of taxpayers whose taxable income is subject to the 45% tax bracket.</summary>
  <committee-reports/>
</bill>


text:
exports.info = { FormatID: '910',
  FormatName: 'Microsoft Office Open XML',
  FormatVersion: '2007 onwards',
  FormatAliases: '',
  FormatFamilies: '',
  FormatTypes: 'Aggregate',
  FormatDisclosure: '',
  FormatDescription: 'Microsoft developed office Open XML (OOXML) in 2007. It is an XML based format representing a departure from previous Microsoft Office suites, which were binary file based. Starting with Microsoft Office 2007, the Office Open XML file formats have become the default file format of Microsoft Office. The ISO standard for OOXML is ISO/IEC DIS 29500. An OOXML file format consists of a compressed zip archive that is designated according to which file type it is. OOXML uses three custom XML based languages to describe its' three document types. WordProcessingML, SpreadsheetML and PresentationML are each used to describe Word, Excel and PowerPoint Presentation files respectively. OOXML is not an open format but the specification and development rights have been released under Microsoft's Covenant not to Sue. OOXML is platform independent.',
  BinaryFileFormat: 'Binary',
  ByteOrders: '',
  ReleaseDate: '',
  WithdrawnDate: '',
  ProvenanceSourceID: '1',
  ProvenanceName: 'Digital Preservation Department / The National Archives',
  ProvenanceSourceDate: '06 Oct 2009',
  ProvenanceDescription: '',
  LastUpdatedDate: '06 Oct 2009',
  FormatNote: '',
  FormatRisk: '',
  TechnicalEnvironment: '',
  FileFormatIdentifier: { Identifier: 'fmt/189', IdentifierType: 'PUID' },
  Developers:
   { DeveloperID: '93',
     DeveloperName: '',
     OrganisationName: 'Microsoft Corporation',
     DeveloperCompoundName: 'Microsoft Corporation' },
  Support:
   { SupportID: '93',
     SupportName: '',
     OrganisationName: 'Microsoft Corporation',
     SupportCompoundName: 'Microsoft Corporation' },
  InternalSignature:
   { SignatureID: '258',
     SignatureName: 'Microsoft Office Open XML',
     SignatureNote: 'Signature represents a combination of OOXML specific bytes and a standard ZIP signature (taken verbatim from Zip format sig). Last two bytes of this signature represents a Microsoft Open Packaging growth hint which indentifies this as one of three OOXML document types so far.',
     ByteSequence:
      { ByteSequenceID: '330',
        PositionType: 'Absolute from BOF',
        Offset: '0',
        MaxOffset: '0',
        IndirectOffsetLocation: '',
        IndirectOffsetLength: '',
        Endianness: 'Little-endian',
        ByteSequenceValue: '504B0304{26}5B436F6E74656E745F54797065735D2E786D6C20A2*504B0102*504B0506' } },
  RelatedFormat:
   { RelationshipType: 'Has priority over',
     RelatedFormatID: '382',
     RelatedFormatName: 'ZIP Format',
     RelatedFormatVersion: '' } }


text:
/*
 * Do not modify this file. This file is generated from the storagegateway-2013-06-30.normal.json service model.
 */
using System;
using System.Collections.Generic;
using System.Xml.Serialization;
using System.Text;
using System.IO;

using Amazon.Runtime;
using Amazon.Runtime.Internal;

namespace Amazon.StorageGateway.Model
{
    ///
    /// Container for the parameters to the CreateTapes operation.
    /// Creates one or more virtual tapes. You write data to the virtual tapes and then archive
    /// the tapes.
    ///
    ///  <note>Cache storage must be allocated to the gateway before you can create virtual
    /// tapes. Use the AddCache operation to add cache storage to a gateway. </note>
    ///
    public partial class CreateTapesRequest : AmazonStorageGatewayRequest
    {
        private string _clientToken;
        private string _gatewayARN;
        private int? _numTapesToCreate;
        private string _tapeBarcodePrefix;
        private long? _tapeSizeInBytes;

        ///
        /// Gets and sets the property ClientToken.
        /// <para>
        /// A unique identifier that you use to retry a request. If you retry a request, use the
        /// same ClientToken you specified in the initial request.
        /// </para>
        ///  <note>Using the same ClientToken prevents creating the tape multiple
        /// times.</note>
        ///
        public string ClientToken
        {
            get { return this._clientToken; }
            set { this._clientToken = value; }
        }

        // Check to see if ClientToken property is set
        internal bool IsSetClientToken()
        {
            return this._clientToken != null;
        }

        ///
        /// Gets and sets the property GatewayARN.
        /// <para>
        /// The unique Amazon Resource Name(ARN) that represents the gateway to associate the
        /// virtual tapes with. Use the ListGateways operation to return a list of gateways
        /// for your account and region.
        /// </para>
        ///
        public string GatewayARN
        {
            get { return this._gatewayARN; }
            set { this._gatewayARN = value; }
        }

        // Check to see if GatewayARN property is set
        internal bool IsSetGatewayARN()
        {
            return this._gatewayARN != null;
        }

        ///
        /// Gets and sets the property NumTapesToCreate.
        /// <para>
        /// The number of virtual tapes you want to create.
        /// </para>
        ///
        public int NumTapesToCreate
        {
            get { return this._numTapesToCreate.GetValueOrDefault(); }
            set { this._numTapesToCreate = value; }
        }

        // Check to see if NumTapesToCreate property is set
        internal bool IsSetNumTapesToCreate()
        {
            return this._numTapesToCreate.HasValue;
        }

        ///
        /// Gets and sets the property TapeBarcodePrefix.
        /// <para>
        /// A prefix you append to the barcode of the virtual tape you are creating. This makes
        /// a barcode unique.
        /// </para>
        ///  <note>The prefix must be 1 to 4 characters in length and must be upper-case letters
        /// A-Z.</note>
        ///
        public string TapeBarcodePrefix
        {
            get { return this._tapeBarcodePrefix; }
            set { this._tapeBarcodePrefix = value; }
        }

        // Check to see if TapeBarcodePrefix property is set
        internal bool IsSetTapeBarcodePrefix()
        {
            return this._tapeBarcodePrefix != null;
        }

        ///
        /// Gets and sets the property TapeSizeInBytes.
        /// <para>
        /// The size, in bytes, of the virtual tapes you want to create.
        /// </para>
        ///  <note>The size must be gigabyte (1024*1024*1024 byte) aligned.</note>
        ///
        public long TapeSizeInBytes
        {
            get { return this._tapeSizeInBytes.GetValueOrDefault(); }
            set { this._tapeSizeInBytes = value; }
        }

        // Check to see if TapeSizeInBytes property is set
        internal bool IsSetTapeSizeInBytes()
        {
            return this._tapeSizeInBytes.HasValue;
        }

    }
}


text:
(function() {
    'use strict';

    angular
        .module('timetrackerApp')
        .constant('paginationConstants', {
            'itemsPerPage': 20
        });
})();


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Ind. Pl. erfurt. Fung. add. 26 (1788)

#### Original name
Boletus fuscoporus J.J. Planer, 1788

### Remarks
null


text:
<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateDosensTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        //
        Schema::create('dosens', function (Blueprint $table) {
            $table->increments('id');
            $table->timestamps();
            $table->string('nik')->unique();
            $table->string('nama_dosen');
            $table->string('foto_dosen');
            $table->integer('jurusan_id')->index();
            $table->integer('fakultas_id')->index();
            $table->string('username');
            $table->string('password');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        //
    }
}


text:
namespace Microsoft.Azure.Management.Compute
{
    using Microsoft.Rest;
    using Microsoft.Rest.Azure;
    using Models;
    using System.Collections;
    using System.Collections.Generic;
    using System.Threading;
    using System.Threading.Tasks;

    /// <summary>
    /// Extension methods for CapacityReservationGroupsOperations.
    /// </summary>
    public static partial class CapacityReservationGroupsOperationsExtensions
    {
            /// <summary>
            /// The operation to create or update a capacity reservation group. When
            /// updating a capacity reservation group, only tags may be modified. Please
            /// refer to https://aka.ms/CapacityReservation for more details.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='capacityReservationGroupName'>
            /// The name of the capacity reservation group.
            /// </param>
            /// <param name='parameters'>
            /// Parameters supplied to the Create capacity reservation Group.
            /// </param>
            public static CapacityReservationGroup CreateOrUpdate(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string capacityReservationGroupName, CapacityReservationGroup parameters)
            {
                return operations.CreateOrUpdateAsync(resourceGroupName, capacityReservationGroupName, parameters).GetAwaiter().GetResult();
            }

            /// <summary>
            /// The operation to create or update a capacity reservation group. When
            /// updating a capacity reservation group, only tags may be modified. Please
            /// refer to https://aka.ms/CapacityReservation for more details.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='capacityReservationGroupName'>
            /// The name of the capacity reservation group.
            /// </param>
            /// <param name='parameters'>
            /// Parameters supplied to the Create capacity reservation Group.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<CapacityReservationGroup> CreateOrUpdateAsync(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string capacityReservationGroupName, CapacityReservationGroup parameters, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, capacityReservationGroupName, parameters, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// The operation to update a capacity reservation group. When updating a
            /// capacity reservation group, only tags may be modified.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='capacityReservationGroupName'>
            /// The name of the capacity reservation group.
            /// </param>
            /// <param name='tags'>
            /// Resource tags
            /// </param>
            public static CapacityReservationGroup Update(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string capacityReservationGroupName, IDictionary<string, string> tags = default(IDictionary<string, string>))
            {
                return operations.UpdateAsync(resourceGroupName, capacityReservationGroupName, tags).GetAwaiter().GetResult();
            }

            /// <summary>
            /// The operation to update a capacity reservation group. When updating a
            /// capacity reservation group, only tags may be modified.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='capacityReservationGroupName'>
            /// The name of the capacity reservation group.
            /// </param>
            /// <param name='tags'>
            /// Resource tags
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<CapacityReservationGroup> UpdateAsync(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string capacityReservationGroupName, IDictionary<string, string> tags = default(IDictionary<string, string>), CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.UpdateWithHttpMessagesAsync(resourceGroupName, capacityReservationGroupName, tags, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// The operation to delete a capacity reservation group. This operation is
            /// allowed only if all the associated resources are disassociated from the
            /// reservation group and all capacity reservations under the reservation group
            /// have also been deleted. Please refer to https://aka.ms/CapacityReservation
            /// for more details.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='capacityReservationGroupName'>
            /// The name of the capacity reservation group.
            /// </param>
            public static void Delete(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string capacityReservationGroupName)
            {
                operations.DeleteAsync(resourceGroupName, capacityReservationGroupName).GetAwaiter().GetResult();
            }

            /// <summary>
            /// The operation to delete a capacity reservation group. This operation is
            /// allowed only if all the associated resources are disassociated from the
            /// reservation group and all capacity reservations under the reservation group
            /// have also been deleted. Please refer to https://aka.ms/CapacityReservation
            /// for more details.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='capacityReservationGroupName'>
            /// The name of the capacity reservation group.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task DeleteAsync(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string capacityReservationGroupName, CancellationToken cancellationToken = default(CancellationToken))
            {
                (await operations.DeleteWithHttpMessagesAsync(resourceGroupName, capacityReservationGroupName, null, cancellationToken).ConfigureAwait(false)).Dispose();
            }

            /// <summary>
            /// The operation that retrieves information about a capacity reservation
            /// group.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='capacityReservationGroupName'>
            /// The name of the capacity reservation group.
            /// </param>
            /// <param name='expand'>
            /// The expand expression to apply on the operation. 'InstanceView' will
            /// retrieve the list of instance views of the capacity reservations under the
            /// capacity reservation group which is a snapshot of the runtime properties of
            /// a capacity reservation that is managed by the platform and can change
            /// outside of control plane operations. Possible values include:
            /// 'instanceView'
            /// </param>
            public static CapacityReservationGroup Get(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string capacityReservationGroupName, string expand = default(string))
            {
                return operations.GetAsync(resourceGroupName, capacityReservationGroupName, expand).GetAwaiter().GetResult();
            }

            /// <summary>
            /// The operation that retrieves information about a capacity reservation
            /// group.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='capacityReservationGroupName'>
            /// The name of the capacity reservation group.
            /// </param>
            /// <param name='expand'>
            /// The expand expression to apply on the operation. 'InstanceView' will
            /// retrieve the list of instance views of the capacity reservations under the
            /// capacity reservation group which is a snapshot of the runtime properties of
            /// a capacity reservation that is managed by the platform and can change
            /// outside of control plane operations. Possible values include:
            /// 'instanceView'
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<CapacityReservationGroup> GetAsync(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string capacityReservationGroupName, string expand = default(string), CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.GetWithHttpMessagesAsync(resourceGroupName, capacityReservationGroupName, expand, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Lists all of the capacity reservation groups in the specified resource
            /// group. Use the nextLink property in the response to get the next page of
            /// capacity reservation groups.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='expand'>
            /// The expand expression to apply on the operation. Based on the expand
            /// param(s) specified we return Virtual Machine or ScaleSet VM Instance or
            /// both resource Ids which are associated to capacity reservation group in the
            /// response. Possible values include: 'virtualMachineScaleSetVMs/$ref',
            /// 'virtualMachines/$ref'
            /// </param>
            public static IPage<CapacityReservationGroup> ListByResourceGroup(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string expand = default(string))
            {
                return operations.ListByResourceGroupAsync(resourceGroupName, expand).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Lists all of the capacity reservation groups in the specified resource
            /// group. Use the nextLink property in the response to get the next page of
            /// capacity reservation groups.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='expand'>
            /// The expand expression to apply on the operation. Based on the expand
            /// param(s) specified we return Virtual Machine or ScaleSet VM Instance or
            /// both resource Ids which are associated to capacity reservation group in the
            /// response. Possible values include: 'virtualMachineScaleSetVMs/$ref',
            /// 'virtualMachines/$ref'
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<CapacityReservationGroup>> ListByResourceGroupAsync(this ICapacityReservationGroupsOperations operations, string resourceGroupName, string expand = default(string), CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListByResourceGroupWithHttpMessagesAsync(resourceGroupName, expand, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Lists all of the capacity reservation groups in the subscription. Use the
            /// nextLink property in the response to get the next page of capacity
            /// reservation groups.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='expand'>
            /// The expand expression to apply on the operation. Based on the expand
            /// param(s) specified we return Virtual Machine or ScaleSet VM Instance or
            /// both resource Ids which are associated to capacity reservation group in the
            /// response. Possible values include: 'virtualMachineScaleSetVMs/$ref',
            /// 'virtualMachines/$ref'
            /// </param>
            public static IPage<CapacityReservationGroup> ListBySubscription(this ICapacityReservationGroupsOperations operations, string expand = default(string))
            {
                return operations.ListBySubscriptionAsync(expand).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Lists all of the capacity reservation groups in the subscription. Use the
            /// nextLink property in the response to get the next page of capacity
            /// reservation groups.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='expand'>
            /// The expand expression to apply on the operation. Based on the expand
            /// param(s) specified we return Virtual Machine or ScaleSet VM Instance or
            /// both resource Ids which are associated to capacity reservation group in the
            /// response. Possible values include: 'virtualMachineScaleSetVMs/$ref',
            /// 'virtualMachines/$ref'
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<CapacityReservationGroup>> ListBySubscriptionAsync(this ICapacityReservationGroupsOperations operations, string expand = default(string), CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListBySubscriptionWithHttpMessagesAsync(expand, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Lists all of the capacity reservation groups in the specified resource
            /// group. Use the nextLink property in the response to get the next page of
            /// capacity reservation groups.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            public static IPage<CapacityReservationGroup> ListByResourceGroupNext(this ICapacityReservationGroupsOperations operations, string nextPageLink)
            {
                return operations.ListByResourceGroupNextAsync(nextPageLink).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Lists all of the capacity reservation groups in the specified resource
            /// group. Use the nextLink property in the response to get the next page of
            /// capacity reservation groups.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<CapacityReservationGroup>> ListByResourceGroupNextAsync(this ICapacityReservationGroupsOperations operations, string nextPageLink, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListByResourceGroupNextWithHttpMessagesAsync(nextPageLink, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Lists all of the capacity reservation groups in the subscription. Use the
            /// nextLink property in the response to get the next page of capacity
            /// reservation groups.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            public static IPage<CapacityReservationGroup> ListBySubscriptionNext(this ICapacityReservationGroupsOperations operations, string nextPageLink)
            {
                return operations.ListBySubscriptionNextAsync(nextPageLink).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Lists all of the capacity reservation groups in the subscription. Use the
            /// nextLink property in the response to get the next page of capacity
            /// reservation groups.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<CapacityReservationGroup>> ListBySubscriptionNextAsync(this ICapacityReservationGroupsOperations operations, string nextPageLink, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListBySubscriptionNextWithHttpMessagesAsync(nextPageLink, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

    }
}


text:
package ehpc

//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//http://www.apache.org/licenses/LICENSE-2.0
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
//
// Code generated by Alibaba Cloud SDK Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

// MountTargetListInListCpfsFileSystems is a nested struct in ehpc response
type MountTargetListInListCpfsFileSystems struct {
	MountTargets []MountTargets `json:"MountTargets" xml:"MountTargets"`
}


text:
define(["Tone/core/Tone", "Tone/instrument/Synth", "Tone/signal/Signal", "Tone/signal/Multiply", "Tone/instrument/Monophonic"],
function(Tone){

	"use strict";

	/**
	 *  @class  FMSynth is composed of two Tone.Synths where one Tone.Synth modulates
	 *          the frequency of a second Tone.Synth. A lot of spectral content
	 *          can be explored using the modulationIndex parameter. Read more about
	 *          frequency modulation synthesis on [SoundOnSound](http://www.soundonsound.com/sos/apr00/articles/synthsecrets.htm).
	 *          <img src="https://docs.google.com/drawings/d/1h0PUDZXPgi4Ikx6bVT6oncrYPLluFKy7lj53puxj-DM/pub?w=902&h=462">
	 *
	 *  @constructor
	 *  @extends {Tone.Monophonic}
	 *  @param {Object} [options] the options available for the synth
	 *                          see defaults below
	 *  @example
	 * var fmSynth = new Tone.FMSynth().toMaster();
	 * fmSynth.triggerAttackRelease("C5", "4n");
	 */
	Tone.FMSynth = function(options){

		options = this.defaultArg(options, Tone.FMSynth.defaults);
		Tone.Monophonic.call(this, options);

		/**
		 *  The carrier voice.
		 *  @type {Tone.Synth}
		 *  @private
		 */
		this._carrier = new Tone.Synth(options.carrier);
		this._carrier.volume.value = -10;

		/**
		 *  The carrier's oscillator
		 *  @type {Tone.Oscillator}
		 */
		this.oscillator = this._carrier.oscillator;

		/**
		 *  The carrier's envelope
		 *  @type {Tone.Oscillator}
		 */
		this.envelope = this._carrier.envelope.set(options.envelope);

		/**
		 *  The modulator voice.
		 *  @type {Tone.Synth}
		 *  @private
		 */
		this._modulator = new Tone.Synth(options.modulator);
		this._modulator.volume.value = -10;

		/**
		 *  The modulator's oscillator which is applied
		 *  to the amplitude of the oscillator
		 *  @type {Tone.Oscillator}
		 */
		this.modulation = this._modulator.oscillator.set(options.modulation);

		/**
		 *  The modulator's envelope
		 *  @type {Tone.Oscillator}
		 */
		this.modulationEnvelope = this._modulator.envelope.set(options.modulationEnvelope);

		/**
		 *  The frequency control.
		 *  @type {Frequency}
		 *  @signal
		 */
		this.frequency = new Tone.Signal(440, Tone.Type.Frequency);

		/**
		 *  The detune in cents
		 *  @type {Cents}
		 *  @signal
		 */
		this.detune = new Tone.Signal(options.detune, Tone.Type.Cents);

		/**
		 *  Harmonicity is the ratio between the two voices. A harmonicity of
		 *  1 is no change. Harmonicity = 2 means a change of an octave.
		 *  @type {Positive}
		 *  @signal
		 *  @example
		 * //pitch voice1 an octave below voice0
		 * synth.harmonicity.value = 0.5;
		 */
		this.harmonicity = new Tone.Multiply(options.harmonicity);
		this.harmonicity.units = Tone.Type.Positive;

		/**
		 *  The modulation index which essentially the depth or amount of the modulation. It is the
		 *  ratio of the frequency of the modulating signal (mf) to the amplitude of the
		 *  modulating signal (ma) -- as in ma/mf.
		 *	@type {Positive}
		 *	@signal
		 */
		this.modulationIndex = new Tone.Multiply(options.modulationIndex);
		this.modulationIndex.units = Tone.Type.Positive;

		/**
		 *  the node where the modulation happens
		 *  @type {GainNode}
		 *  @private
		 */
		this._modulationNode = new Tone.Gain(0);

		//control the two voices frequency
		this.frequency.connect(this._carrier.frequency);
		this.frequency.chain(this.harmonicity, this._modulator.frequency);
		this.frequency.chain(this.modulationIndex, this._modulationNode);
		this.detune.fan(this._carrier.detune, this._modulator.detune);
		this._modulator.connect(this._modulationNode.gain);
		this._modulationNode.connect(this._carrier.frequency);
		this._carrier.connect(this.output);
		this._readOnly(["frequency", "harmonicity", "modulationIndex", "oscillator", "envelope", "modulation", "modulationEnvelope", "detune"]);
	};

	Tone.extend(Tone.FMSynth, Tone.Monophonic);

	/**
	 *  @static
	 *  @type {Object}
	 */
	Tone.FMSynth.defaults = {
		"harmonicity" : 3,
		"modulationIndex" : 10,
		"detune" : 0,
		"oscillator" : {
			"type" : "sine"
		},
		"envelope" : {
			"attack" : 0.01,
			"decay" : 0.01,
			"sustain" : 1,
			"release" : 0.5
		},
		"modulation" : {
			"type" : "square"
		},
		"modulationEnvelope" : {
			"attack" : 0.5,
			"decay" : 0.0,
			"sustain" : 1,
			"release" : 0.5
		}
	};

	/**
	 * 	trigger the attack portion of the note
	 *
	 *  @param  {Time} [time=now] the time the note will occur
	 *  @param {number} [velocity=1] the velocity of the note
	 *  @returns {Tone.FMSynth} this
	 *  @private
	 */
	Tone.FMSynth.prototype._triggerEnvelopeAttack = function(time, velocity){
		time = this.toSeconds(time);
		//the envelopes
		this.envelope.triggerAttack(time, velocity);
		this.modulationEnvelope.triggerAttack(time);
		return this;
	};

	/**
	 *  trigger the release portion of the note
	 *
	 *  @param  {Time} [time=now] the time the note will release
	 *  @returns {Tone.FMSynth} this
	 *  @private
	 */
	Tone.FMSynth.prototype._triggerEnvelopeRelease = function(time){
		time = this.toSeconds(time);
		this.envelope.triggerRelease(time);
		this.modulationEnvelope.triggerRelease(time);
		return this;
	};

	/**
	 *  clean up
	 *  @returns {Tone.FMSynth} this
	 */
	Tone.FMSynth.prototype.dispose = function(){
		Tone.Monophonic.prototype.dispose.call(this);
		this._writable(["frequency", "harmonicity", "modulationIndex", "oscillator", "envelope", "modulation", "modulationEnvelope", "detune"]);
		this._carrier.dispose();
		this._carrier = null;
		this._modulator.dispose();
		this._modulator = null;
		this.frequency.dispose();
		this.frequency = null;
		this.detune.dispose();
		this.detune = null;
		this.modulationIndex.dispose();
		this.modulationIndex = null;
		this.harmonicity.dispose();
		this.harmonicity = null;
		this._modulationNode.dispose();
		this._modulationNode = null;
		this.oscillator = null;
		this.envelope = null;
		this.modulationEnvelope = null;
		this.modulation = null;
		return this;
	};

	return Tone.FMSynth;
});


text:
from ._service_operations import ServiceOperations
from ._file_system_operations import FileSystemOperations
from ._path_operations import PathOperations

from ._patch import __all__ as _patch_all
from ._patch import *  # type: ignore # pylint: disable=unused-wildcard-import
from ._patch import patch_sdk as _patch_sdk

__all__ = [
    "ServiceOperations",
    "FileSystemOperations",
    "PathOperations",
]
__all__.extend([p for p in _patch_all if p not in __all__])
_patch_sdk()


text:
package org.wso2.apiManager.plugin;

public class ActionGroups {

    /*
     * Actions applied to the workspace. They will also be inserted into the File menu of SoapUI.
     * Have your action class extend AbstractSoapUIAction<WorkspaceImpl>.
     */
    public static final String WORKSPACE_ACTIONS = "WorkspaceImplActions";

    /*
     * Actions applied to all projects, regardless of the state (enabled, disabled; closed or opened; encrypted or not.
     * Have your action class extend AbstractSoapUIAction<WsdlProject>.
     */
    public static final String PROJECT_ACTIONS = "WsdlProjectActions";

    /*
     * Actions applied to opened projects. If you're writing a project level action, this is usually the action group
     * you want it in.
     *
     * Have your action class extend AbstractSoapUIAction<WsdlProject>.
     */
    public static final String OPEN_PROJECT_ACTIONS = "EnabledWsdlProjectActions";

    /*
     * Actions applied to opened composite projects. If you're writing a project level action that applies to composite
     * projects, you usually want to include this action group, e.g. by using the @ActionConfigurations annotation.
     *
     * Have your action class extend AbstractSoapUIAction<WsdlProject>.
     */
    public static final String OPEN_COMPOSITE_PROJECT_ACTIONS = "CompositeWsdlProjectActions";

    /*
    * Actions applied to closed projects.
    *
    * Have your action class extend AbstractSoapUIAction<WsdlProject>.
    */
    public static final String CLOSED_PROJECT_ACTIONS = "ClosedWsdlProjectActions";

    /*
     * Actions applied to encrypted projects.
     * Have your action class extend AbstractSoapUIAction<WsdlProject>.
     */
    public static final String ENCRYPTED_PROJECT_ACTIONS = "EncryptedWsdlProjectActions";

    /*
     * Actions applied to both SOAP and REST services.
     * Have your action class extend AbstractSoapUIAction<WsdlInterface>.
     */
    public static final String INTERFACE_ACTIONS = "WsdlInterfaceActions";

    /*
     * Actions applied only to REST services.
     * Have your action class extend AbstractSoapUIAction<RestService>.
     */
    public static final String REST_SERVICE_ACTIONS = "RestServiceActions";

    /*
     * Actions applied to SOAP services.
     * Have your action class extend AbstractSoapUIAction<RestResource>.
     */
    public static final String REST_RESOURCE_ACTIONS = "RestResourceActions";

    /*
     * Actions applied only to REST method nodes, i.e. the level below the REST resource, most often named GET or POST.
     * Have your action class extend AbstractSoapUIAction<RestMethod>.
     */
    public static final String REST_METHOD_ACTIONS = "RestMethodActions";

    /*
     * Actions applied to REST requests.
     * Have your action class extend AbstractSoapUIAction<RestRequest>.
     */
    public static final String REST_REQUEST_ACTIONS = "RestMethodActions";

    /*
     * Actions applied to SOAP operations.
     * Have your action class extend AbstractSoapUIAction<WsdlOperation>.
     */
    public static final String SOAP_OPERATION_ACTIONS = "WsdlOperationActions";

    /*
     * Actions applied to SOAP operations.
     * Have your action class extend AbstractSoapUIAction<WsdlOperation>.
     */
    public static final String SOAP_REQUEST_ACTIONS = "WsdlRequestActions";

    /*
     * Actions applied to test suites.
     * Have your action class extend AbstractSoapUIAction<WsdlTestSuite>.
     */
    public static final String TEST_SUITE_ACTIONS = "WsdlTestSuiteActions";

    /*
     * Actions applied to test cases.
     * Have your action class extend AbstractSoapUIAction<WsdlTestCase>.
     */
    public static final String TEST_CASE_ACTIONS = "WsdlTestSuiteActions";

    /*
     * Actions applied to all test steps.
     * Have your action class extend AbstractSoapUIAction<WsdlTestStep>.
     */
    public static final String TEST_STEP_ACTIONS = "WsdlTestStepActions";

    /*
     * Actions applied only to REST requests test steps.
     * Have your action class extend AbstractSoapUIAction<RestTestRequestStep>.
     */
    public static final String REST_TEST_REQUEST_ACTIONS = "RestTestRequestStepActions";

    /*
     * Actions applied to SOAP operations.
     * Have your action class extend AbstractSoapUIAction<WsdlOperation>.
     */
    public static final String SOAP_TEST_REQUEST_ACTIONS = "WsdlTestRequestStepActions";

    /*
     * Actions applied to assertions.
     * Have your action class extend AbstractSoapUIAction<WsdlMessageAssertion>.
     */
    public static final String ASSERTION_ACTIONS = "WsdlMessageAssertionActions";

}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>FunctionFactory (Apache Jena ARQ)</title>
<meta name="date" content="2014-10-02">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

com.hp.hpl.jena.sparql.function

Interface FunctionFactory

All Known Implementing Classes:

CastXSD, CastXSD_Boolean, CastXSD_DateTime, CastXSD_Numeric, UserDefinedFunctionFactory

public interface FunctionFactory

Interface for function factories.

Method Summary

Methods

Modifier and Type
Method and Description

Function
create(String uri)

Create a function with the given URI

Method Detail

create

Function create(String uri)

Create a function with the given URI

Parameters:

uri - URI

Returns:

Function

Throws:

ExprBuildException - May be thrown if there is a problem creating a function

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

Licenced under the Apache License, Version 2.0


text:
#if !defined(BOOST_FUSION_ITERATOR_RANGE_SIZE_IMPL_HPP_INCLUDED)
#define BOOST_FUSION_ITERATOR_RANGE_SIZE_IMPL_HPP_INCLUDED

#include <lslboost/fusion/iterator/distance.hpp>

namespace lslboost { namespace fusion
{
    struct iterator_range_tag;

    namespace extension
    {
        template <typename Tag>
        struct size_impl;

        template <>
        struct size_impl<iterator_range_tag>
        {
            template <typename Seq>
            struct apply
              : result_of::distance<
                    typename Seq::begin_type,
                    typename Seq::end_type
                >
            {};
        };
    }
}}

#endif


text:
using System;
using System.Windows.Controls;

namespace VoiceroidUtil.View
{
    /// <summary>
    /// MovableValue を設定するユーザコントロールクラス。
    /// </summary>
    public partial class MovableValueControl : UserControl
    {
        /// <summary>
        /// コンストラクタ。
        /// </summary>
        public MovableValueControl() => this.InitializeComponent();
    }
}


text:
/* OVERLAYS */

/* Container for all overlays */
.overlay-container,
.modals-container,
.modal-container {
  position: fixed;
  left: 0;
  top: 0;
  height: 100%;
  width: 100%;
  overflow: hidden;
  display: flex;
  align-items: center;
  justify-content: center;
  z-index: var(--z08-overlay);
}

.overlay-container {
  pointer-events: none;
}


text:
package tidy

import (
	"bytes"
	"fmt"
	"os"
	"strings"
	"xml"
)

// String returns a string form of the xml.Name object.
func String(name xml.Name) string {
	if len(name.Space) > 0 {
		return fmt.Sprintf("%s:%s", name.Space, name.Local)
	}
	return name.Local
}

// indentation is the string to use as a single indentation level
var indentation = "  "

// Tidy takes an HTML string and tidys it up.
func Tidy(str string) (html string, err os.Error) {
	parser := xml.NewParser(strings.NewReader(str))
	// read str, token by token, and spit it out
	//
	// xml.Parser does most of the work for us here - we do a small
	// bit by indenting
	indent := 0 // the current indent level
	token, err := parser.Token()
	inpre := false // true if we are in a <pre> tag
	for err == nil {
		switch token.(type) {
		case xml.StartElement:
			elem := token.(xml.StartElement)
			if !inpre {
				for i := 0; i < indent; i++ {
					html += indentation
				}
			}
			html += "<" + String(elem.Name)
			for _, attr := range elem.Attr {
				html += fmt.Sprintf(" %s=\"%s\"",
					String(attr.Name),
					attr.Value)
			}
			html += ">"
			if String(elem.Name)=="pre" {
				inpre = true
			}
			if !inpre {
				html+="\n"
			}
			indent++
		case xml.EndElement:
			elem := token.(xml.EndElement)
			indent--
			if !inpre {
				for i := 0; i < indent; i++ {
					html += indentation
				}
			}
			html += fmt.Sprintf("</%s>", String(elem.Name))
			if String(elem.Name)=="pre" {
				inpre = false
			}
			if !inpre {
				html += fmt.Sprintf("\n")
			}
		case xml.CharData:
			data := token.(xml.CharData)
			str := bytes.NewBuffer(data).String()
			if !inpre {
				str = strings.Trim(str, " \r\n\t")
			}
			if len(str) > 0 {
				if !inpre {
					for i := 0; i < indent; i++ {
						html += indentation
					}
				}
				html += str
				if !inpre {
					html += "\n"
				}
			}
		case xml.Comment:
			// don't print comments
		case xml.ProcInst:
			// TODO handle these somehow (server-side xslt?)
		case xml.Directive:
			// just spit it out
			directive := token.(xml.Directive)
			html += "<!" + bytes.NewBuffer(directive).String() + ">"
		default:
			// yikes! Not much to do about this...
		}
		token, err = parser.Token()
	}
	if err != os.EOF {
		fmt.Fprint(os.Stderr, err)
		// return the original string
		return str, err
	}
	err = nil
	return
}


text:
/*
 * array.c
 *
 */

#include <assert.h>
#include <roaring/containers/array.h>
#include <stdio.h>
#include <stdlib.h>

extern inline uint16_t array_container_minimum(const array_container_t *arr);
extern inline uint16_t array_container_maximum(const array_container_t *arr);
extern inline int array_container_index_equalorlarger(const array_container_t *arr, uint16_t x);

extern inline int array_container_rank(const array_container_t *arr,
                                       uint16_t x);
extern inline bool array_container_contains(const array_container_t *arr,
                                            uint16_t pos);
extern inline int array_container_cardinality(const array_container_t *array);
extern inline bool array_container_nonzero_cardinality(const array_container_t *array);
extern inline void array_container_clear(array_container_t *array);
extern inline int32_t array_container_serialized_size_in_bytes(int32_t card);
extern inline bool array_container_empty(const array_container_t *array);
extern inline bool array_container_full(const array_container_t *array);

/* Create a new array with capacity size. Return NULL in case of failure. */
array_container_t *array_container_create_given_capacity(int32_t size) {
    array_container_t *container;

    if ((container = (array_container_t *)malloc(sizeof(array_container_t))) ==
        NULL) {
        return NULL;
    }

    if( size <= 0 ) { // we don't want to rely on malloc(0)
        container->array = NULL;
    } else if ((container->array = (uint16_t *)malloc(sizeof(uint16_t) * size)) ==
        NULL) {
        free(container);
        return NULL;
    }

    container->capacity = size;
    container->cardinality = 0;

    return container;
}

/* Create a new array. Return NULL in case of failure. */
array_container_t *array_container_create() {
    return array_container_create_given_capacity(ARRAY_DEFAULT_INIT_SIZE);
}

/* Create a new array containing all values in [min,max). */
array_container_t * array_container_create_range(uint32_t min, uint32_t max) {
    array_container_t * answer = array_container_create_given_capacity(max - min + 1);
    if(answer == NULL) return answer;
    answer->cardinality = 0;
    for(uint32_t k = min; k < max; k++) {
      answer->array[answer->cardinality++] = k;
    }
    return answer;
}

/* Duplicate container */
array_container_t *array_container_clone(const array_container_t *src) {
    array_container_t *newcontainer =
        array_container_create_given_capacity(src->capacity);
    if (newcontainer == NULL) return NULL;

    newcontainer->cardinality = src->cardinality;

    memcpy(newcontainer->array, src->array,
           src->cardinality * sizeof(uint16_t));

    return newcontainer;
}

int array_container_shrink_to_fit(array_container_t *src) {
    if (src->cardinality == src->capacity) return 0;  // nothing to do
    int savings = src->capacity - src->cardinality;
    src->capacity = src->cardinality;
    if( src->capacity == 0) { // we do not want to rely on realloc for zero allocs
      free(src->array);
      src->array = NULL;
    } else {
      uint16_t *oldarray = src->array;
      src->array =
        (uint16_t *)realloc(oldarray, src->capacity * sizeof(uint16_t));
      if (src->array == NULL) free(oldarray);  // should never happen?
    }
    return savings;
}

/* Free memory. */
void array_container_free(array_container_t *arr) {
    if(arr->array != NULL) {// Jon Strabala reports that some tools complain otherwise
      free(arr->array);
      arr->array = NULL; // pedantic
    }
    free(arr);
}

static inline int32_t grow_capacity(int32_t capacity) {
    return (capacity <= 0) ? ARRAY_DEFAULT_INIT_SIZE
                           : capacity < 64 ? capacity * 2
                                           : capacity < 1024 ? capacity * 3 / 2
                                                             : capacity * 5 / 4;
}

static inline int32_t clamp(int32_t val, int32_t min, int32_t max) {
    return ((val < min) ? min : (val > max) ? max : val);
}

void array_container_grow(array_container_t *container, int32_t min,
                          bool preserve) {

    int32_t max = (min <= DEFAULT_MAX_SIZE ? DEFAULT_MAX_SIZE : 65536);
    int32_t new_capacity = clamp(grow_capacity(container->capacity), min, max);

    container->capacity = new_capacity;
    uint16_t *array = container->array;

    if (preserve) {
        container->array =
            (uint16_t *)realloc(array, new_capacity * sizeof(uint16_t));
        if (container->array == NULL) free(array);
    } else {
        // Jon Strabala reports that some tools complain otherwise
        if (array != NULL) {
          free(array);
        }
        container->array = (uint16_t *)malloc(new_capacity * sizeof(uint16_t));
    }

    //  handle the case where realloc fails
    if (container->array == NULL) {
      fprintf(stderr, "could not allocate memory\n");
    }
    assert(container->array != NULL);
}

/* Copy one container into another. We assume that they are distinct. */
void array_container_copy(const array_container_t *src,
                          array_container_t *dst) {
    const int32_t cardinality = src->cardinality;
    if (cardinality > dst->capacity) {
        array_container_grow(dst, cardinality, false);
    }

    dst->cardinality = cardinality;
    memcpy(dst->array, src->array, cardinality * sizeof(uint16_t));
}

void array_container_add_from_range(array_container_t *arr, uint32_t min,
                                    uint32_t max, uint16_t step) {
    for (uint32_t value = min; value < max; value += step) {
        array_container_append(arr, value);
    }
}

/* Computes the union of array1 and array2 and write the result to arrayout.
 * It is assumed that arrayout is distinct from both array1 and array2.
 */
void array_container_union(const array_container_t *array_1,
                           const array_container_t *array_2,
                           array_container_t *out) {
    const int32_t card_1 = array_1->cardinality, card_2 = array_2->cardinality;
    const int32_t max_cardinality = card_1 + card_2;

    if (out->capacity < max_cardinality) {
      array_container_grow(out, max_cardinality, false);
    }
    out->cardinality = (int32_t)fast_union_uint16(array_1->array, card_1,
                                      array_2->array, card_2, out->array);

}

/* Computes the  difference of array1 and array2 and write the result
 * to array out.
 * Array out does not need to be distinct from array_1
 */
void array_container_andnot(const array_container_t *array_1,
                            const array_container_t *array_2,
                            array_container_t *out) {
    if (out->capacity < array_1->cardinality)
        array_container_grow(out, array_1->cardinality, false);
#ifdef ROARING_VECTOR_OPERATIONS_ENABLED
    if((out != array_1) && (out != array_2)) {
      out->cardinality =
          difference_vector16(array_1->array, array_1->cardinality,
                            array_2->array, array_2->cardinality, out->array);
     } else {
      out->cardinality =
        difference_uint16(array_1->array, array_1->cardinality, array_2->array,
                          array_2->cardinality, out->array);
     }
#else
    out->cardinality =
        difference_uint16(array_1->array, array_1->cardinality, array_2->array,
                          array_2->cardinality, out->array);
#endif
}

/* Computes the symmetric difference of array1 and array2 and write the
 * result
 * to arrayout.
 * It is assumed that arrayout is distinct from both array1 and array2.
 */
void array_container_xor(const array_container_t *array_1,
                         const array_container_t *array_2,
                         array_container_t *out) {
    const int32_t card_1 = array_1->cardinality, card_2 = array_2->cardinality;
    const int32_t max_cardinality = card_1 + card_2;
    if (out->capacity < max_cardinality) {
        array_container_grow(out, max_cardinality, false);
    }

#ifdef ROARING_VECTOR_OPERATIONS_ENABLED
    out->cardinality =
        xor_vector16(array_1->array, array_1->cardinality, array_2->array,
                     array_2->cardinality, out->array);
#else
    out->cardinality =
        xor_uint16(array_1->array, array_1->cardinality, array_2->array,
                   array_2->cardinality, out->array);
#endif
}

static inline int32_t minimum_int32(int32_t a, int32_t b) {
    return (a < b) ? a : b;
}

/* computes the intersection of array1 and array2 and write the result to
 * arrayout.
 * It is assumed that arrayout is distinct from both array1 and array2.
 * */
void array_container_intersection(const array_container_t *array1,
                                  const array_container_t *array2,
                                  array_container_t *out) {
    int32_t card_1 = array1->cardinality, card_2 = array2->cardinality,
            min_card = minimum_int32(card_1, card_2);
    const int threshold = 64;  // subject to tuning
#ifdef USEAVX
    if (out->capacity < min_card) {
      array_container_grow(out, min_card + sizeof(__m128i) / sizeof(uint16_t),
        false);
    }
#else
    if (out->capacity < min_card) {
      array_container_grow(out, min_card, false);
    }
#endif

    if (card_1 * threshold < card_2) {
        out->cardinality = intersect_skewed_uint16(
            array1->array, card_1, array2->array, card_2, out->array);
    } else if (card_2 * threshold < card_1) {
        out->cardinality = intersect_skewed_uint16(
            array2->array, card_2, array1->array, card_1, out->array);
    } else {
#ifdef USEAVX
        out->cardinality = intersect_vector16(
            array1->array, card_1, array2->array, card_2, out->array);
#else
        out->cardinality = intersect_uint16(array1->array, card_1,
                                            array2->array, card_2, out->array);
#endif
    }
}

/* computes the size of the intersection of array1 and array2
 * */
int array_container_intersection_cardinality(const array_container_t *array1,
                                             const array_container_t *array2) {
    int32_t card_1 = array1->cardinality, card_2 = array2->cardinality;
    const int threshold = 64;  // subject to tuning
    if (card_1 * threshold < card_2) {
        return intersect_skewed_uint16_cardinality(array1->array, card_1,
                                                   array2->array, card_2);
    } else if (card_2 * threshold < card_1) {
        return intersect_skewed_uint16_cardinality(array2->array, card_2,
                                                   array1->array, card_1);
    } else {
#ifdef USEAVX
        return intersect_vector16_cardinality(array1->array, card_1,
                                              array2->array, card_2);
#else
        return intersect_uint16_cardinality(array1->array, card_1,
                                            array2->array, card_2);
#endif
    }
}

bool array_container_intersect(const array_container_t *array1,
                                  const array_container_t *array2) {
    int32_t card_1 = array1->cardinality, card_2 = array2->cardinality;
    const int threshold = 64;  // subject to tuning
    if (card_1 * threshold < card_2) {
        return intersect_skewed_uint16_nonempty(
            array1->array, card_1, array2->array, card_2);
    } else if (card_2 * threshold < card_1) {
    	return intersect_skewed_uint16_nonempty(
            array2->array, card_2, array1->array, card_1);
    } else {
    	// we do not bother vectorizing
        return intersect_uint16_nonempty(array1->array, card_1,
                                            array2->array, card_2);
    }
}

/* computes the intersection of array1 and array2 and write the result to
 * array1.
 * */
void array_container_intersection_inplace(array_container_t *src_1,
                                          const array_container_t *src_2) {
    // todo: can any of this be vectorized?
    int32_t card_1 = src_1->cardinality, card_2 = src_2->cardinality;
    const int threshold = 64;  // subject to tuning
    if (card_1 * threshold < card_2) {
        src_1->cardinality = intersect_skewed_uint16(
            src_1->array, card_1, src_2->array, card_2, src_1->array);
    } else if (card_2 * threshold < card_1) {
        src_1->cardinality = intersect_skewed_uint16(
            src_2->array, card_2, src_1->array, card_1, src_1->array);
    } else {
        src_1->cardinality = intersect_uint16(
            src_1->array, card_1, src_2->array, card_2, src_1->array);
    }
}

int array_container_to_uint32_array(void *vout, const array_container_t *cont,
                                    uint32_t base) {
    int outpos = 0;
    uint32_t *out = (uint32_t *)vout;
    for (int i = 0; i < cont->cardinality; ++i) {
        const uint32_t val = base + cont->array[i];
        memcpy(out + outpos, &val,
               sizeof(uint32_t));  // should be compiled as a MOV on x64
        outpos++;
    }
    return outpos;
}

void array_container_printf(const array_container_t *v) {
    if (v->cardinality == 0) {
        printf("{}");
        return;
    }
    printf("{");
    printf("%d", v->array[0]);
    for (int i = 1; i < v->cardinality; ++i) {
        printf(",%d", v->array[i]);
    }
    printf("}");
}

void array_container_printf_as_uint32_array(const array_container_t *v,
                                            uint32_t base) {
    if (v->cardinality == 0) {
        return;
    }
    printf("%u", v->array[0] + base);
    for (int i = 1; i < v->cardinality; ++i) {
        printf(",%u", v->array[i] + base);
    }
}

/* Compute the number of runs */
int32_t array_container_number_of_runs(const array_container_t *a) {
    // Can SIMD work here?
    int32_t nr_runs = 0;
    int32_t prev = -2;
    for (const uint16_t *p = a->array; p != a->array + a->cardinality; ++p) {
        if (*p != prev + 1) nr_runs++;
        prev = *p;
    }
    return nr_runs;
}

int32_t array_container_serialize(const array_container_t *container, char *buf) {
    int32_t l, off;
    uint16_t cardinality = (uint16_t)container->cardinality;

    memcpy(buf, &cardinality, off = sizeof(cardinality));
    l = sizeof(uint16_t) * container->cardinality;
    if (l) memcpy(&buf[off], container->array, l);

    return (off + l);
}

/**
 * Writes the underlying array to buf, outputs how many bytes were written.
 * The number of bytes written should be
 * array_container_size_in_bytes(container).
 *
 */
int32_t array_container_write(const array_container_t *container, char *buf) {
    memcpy(buf, container->array, container->cardinality * sizeof(uint16_t));
    return array_container_size_in_bytes(container);
}

bool array_container_is_subset(const array_container_t *container1,
                               const array_container_t *container2) {
    if (container1->cardinality > container2->cardinality) {
        return false;
    }
    int i1 = 0, i2 = 0;
    while (i1 < container1->cardinality && i2 < container2->cardinality) {
        if (container1->array[i1] == container2->array[i2]) {
            i1++;
            i2++;
        } else if (container1->array[i1] > container2->array[i2]) {
            i2++;
        } else {  // container1->array[i1] < container2->array[i2]
            return false;
        }
    }
    if (i1 == container1->cardinality) {
        return true;
    } else {
        return false;
    }
}

int32_t array_container_read(int32_t cardinality, array_container_t *container,
                             const char *buf) {
    if (container->capacity < cardinality) {
        array_container_grow(container, cardinality, false);
    }
    container->cardinality = cardinality;
    memcpy(container->array, buf, container->cardinality * sizeof(uint16_t));

    return array_container_size_in_bytes(container);
}

uint32_t array_container_serialization_len(const array_container_t *container) {
    return (sizeof(uint16_t) /* container->cardinality converted to 16 bit */ +
            (sizeof(uint16_t) * container->cardinality));
}

void *array_container_deserialize(const char *buf, size_t buf_len) {
    array_container_t *ptr;

    if (buf_len < 2) /* capacity converted to 16 bit */
        return (NULL);
    else
        buf_len -= 2;

    if ((ptr = (array_container_t *)malloc(sizeof(array_container_t))) !=
        NULL) {
        size_t len;
        int32_t off;
        uint16_t cardinality;

        memcpy(&cardinality, buf, off = sizeof(cardinality));

        ptr->capacity = ptr->cardinality = (uint32_t)cardinality;
        len = sizeof(uint16_t) * ptr->cardinality;

        if (len != buf_len) {
            free(ptr);
            return (NULL);
        }

        if ((ptr->array = (uint16_t *)malloc(sizeof(uint16_t) *
                                             ptr->capacity)) == NULL) {
            free(ptr);
            return (NULL);
        }

        if (len) memcpy(ptr->array, &buf[off], len);

        /* Check if returned values are monotonically increasing */
        for (int32_t i = 0, j = 0; i < ptr->cardinality; i++) {
            if (ptr->array[i] < j) {
                free(ptr->array);
                free(ptr);
                return (NULL);
            } else
                j = ptr->array[i];
        }
    }

    return (ptr);
}

bool array_container_iterate(const array_container_t *cont, uint32_t base,
                             roaring_iterator iterator, void *ptr) {
    for (int i = 0; i < cont->cardinality; i++)
        if (!iterator(cont->array[i] + base, ptr)) return false;
    return true;
}

bool array_container_iterate64(const array_container_t *cont, uint32_t base,
                               roaring_iterator64 iterator, uint64_t high_bits,
                               void *ptr) {
    for (int i = 0; i < cont->cardinality; i++)
        if (!iterator(high_bits | (uint64_t)(cont->array[i] + base), ptr))
            return false;
    return true;
}


text:
package provider

import (
	"context"
	"net/http"
	"strings"

	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2020-12-01/compute"
	"github.com/Azure/go-autorest/autorest/azure"
	"github.com/Azure/go-autorest/autorest/to"

	"k8s.io/apimachinery/pkg/types"
	"k8s.io/klog/v2"

	azcache "sigs.k8s.io/cloud-provider-azure/pkg/cache"
	"sigs.k8s.io/cloud-provider-azure/pkg/consts"
)

// AttachDisk attaches a disk to vm
func (as *availabilitySet) AttachDisk(nodeName types.NodeName, diskMap map[string]*AttachDiskOptions) (*azure.Future, error) {
	vm, err := as.getVirtualMachine(nodeName, azcache.CacheReadTypeDefault)
	if err != nil {
		return nil, err
	}

	vmName := mapNodeNameToVMName(nodeName)
	nodeResourceGroup, err := as.GetNodeResourceGroup(vmName)
	if err != nil {
		return nil, err
	}

	disks := make([]compute.DataDisk, len(*vm.StorageProfile.DataDisks))
	copy(disks, *vm.StorageProfile.DataDisks)

	for k, v := range diskMap {
		diskURI := k
		opt := v
		attached := false
		for _, disk := range *vm.StorageProfile.DataDisks {
			if disk.ManagedDisk != nil && strings.EqualFold(*disk.ManagedDisk.ID, diskURI) {
				attached = true
				break
			}
		}
		if attached {
			klog.V(2).Infof("azureDisk - disk(%s) already attached to node(%s)", diskURI, nodeName)
			continue
		}

		managedDisk := &compute.ManagedDiskParameters{ID: &diskURI}
		if opt.diskEncryptionSetID == "" {
			if vm.StorageProfile.OsDisk != nil &&
				vm.StorageProfile.OsDisk.ManagedDisk != nil &&
				vm.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet != nil &&
				vm.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet.ID != nil {
				// set diskEncryptionSet as value of os disk by default
				opt.diskEncryptionSetID = *vm.StorageProfile.OsDisk.ManagedDisk.DiskEncryptionSet.ID
			}
		}
		if opt.diskEncryptionSetID != "" {
			managedDisk.DiskEncryptionSet = &compute.DiskEncryptionSetParameters{ID: &opt.diskEncryptionSetID}
		}
		disks = append(disks,
			compute.DataDisk{
				Name:                    &opt.diskName,
				Lun:                     &opt.lun,
				Caching:                 opt.cachingMode,
				CreateOption:            "attach",
				ManagedDisk:             managedDisk,
				WriteAcceleratorEnabled: to.BoolPtr(opt.writeAcceleratorEnabled),
			})
	}

	newVM := compute.VirtualMachineUpdate{
		VirtualMachineProperties: &compute.VirtualMachineProperties{
			StorageProfile: &compute.StorageProfile{
				DataDisks: &disks,
			},
		},
	}
	klog.V(2).Infof("azureDisk - update(%s): vm(%s) - attach disk list(%s)", nodeResourceGroup, vmName, diskMap)
	ctx, cancel := getContextWithCancel()
	defer cancel()

	// Invalidate the cache right after updating
	defer func() {
		_ = as.cloud.vmCache.Delete(vmName)
	}()

	future, rerr := as.VirtualMachinesClient.UpdateAsync(ctx, nodeResourceGroup, vmName, newVM, "attach_disk")
	if rerr != nil {
		klog.Errorf("azureDisk - attach disk list(%s) on rg(%s) vm(%s) failed, err: %v", diskMap, nodeResourceGroup, vmName, rerr)
		if rerr.HTTPStatusCode == http.StatusNotFound {
			klog.Errorf("azureDisk - begin to filterNonExistingDisks(%v) on rg(%s) vm(%s)", diskMap, nodeResourceGroup, vmName)
			disks := as.filterNonExistingDisks(ctx, *newVM.VirtualMachineProperties.StorageProfile.DataDisks)
			newVM.VirtualMachineProperties.StorageProfile.DataDisks = &disks
			future, rerr = as.VirtualMachinesClient.UpdateAsync(ctx, nodeResourceGroup, vmName, newVM, "attach_disk")
		}
	}

	klog.V(2).Infof("azureDisk - update(%s): vm(%s) - attach disk list(%s) returned with %v", nodeResourceGroup, vmName, diskMap, rerr)
	if rerr != nil {
		return future, rerr.Error()
	}
	return future, nil
}

// WaitForUpdateResult waits for the response of the update request
func (as *availabilitySet) WaitForUpdateResult(ctx context.Context, future *azure.Future, resourceGroupName, source string) error {
	if rerr := as.VirtualMachinesClient.WaitForUpdateResult(ctx, future, resourceGroupName, source); rerr != nil {
		return rerr.Error()
	}
	return nil
}

// DetachDisk detaches a disk from VM
func (as *availabilitySet) DetachDisk(nodeName types.NodeName, diskMap map[string]string) error {
	vm, err := as.getVirtualMachine(nodeName, azcache.CacheReadTypeDefault)
	if err != nil {
		// if host doesn't exist, no need to detach
		klog.Warningf("azureDisk - cannot find node %s, skip detaching disk list(%s)", nodeName, diskMap)
		return nil
	}

	vmName := mapNodeNameToVMName(nodeName)
	nodeResourceGroup, err := as.GetNodeResourceGroup(vmName)
	if err != nil {
		return err
	}

	disks := make([]compute.DataDisk, len(*vm.StorageProfile.DataDisks))
	copy(disks, *vm.StorageProfile.DataDisks)

	bFoundDisk := false
	for i, disk := range disks {
		for diskURI, diskName := range diskMap {
			if disk.Lun != nil && (disk.Name != nil && diskName != "" && strings.EqualFold(*disk.Name, diskName)) ||
				(disk.Vhd != nil && disk.Vhd.URI != nil && diskURI != "" && strings.EqualFold(*disk.Vhd.URI, diskURI)) ||
				(disk.ManagedDisk != nil && diskURI != "" && strings.EqualFold(*disk.ManagedDisk.ID, diskURI)) {
				// found the disk
				klog.V(2).Infof("azureDisk - detach disk: name %q uri %q", diskName, diskURI)
				disks[i].ToBeDetached = to.BoolPtr(true)
				bFoundDisk = true
			}
		}
	}

	if !bFoundDisk {
		// only log here, next action is to update VM status with original meta data
		klog.Errorf("detach azure disk on node(%s): disk list(%s) not found", nodeName, diskMap)
	} else {
		if strings.EqualFold(as.cloud.Environment.Name, consts.AzureStackCloudName) && !as.Config.DisableAzureStackCloud {
			// Azure stack does not support ToBeDetached flag, use original way to detach disk
			newDisks := []compute.DataDisk{}
			for _, disk := range disks {
				if !to.Bool(disk.ToBeDetached) {
					newDisks = append(newDisks, disk)
				}
			}
			disks = newDisks
		}
	}

	newVM := compute.VirtualMachineUpdate{
		VirtualMachineProperties: &compute.VirtualMachineProperties{
			StorageProfile: &compute.StorageProfile{
				DataDisks: &disks,
			},
		},
	}
	klog.V(2).Infof("azureDisk - update(%s): vm(%s) - detach disk list(%s)", nodeResourceGroup, vmName, nodeName, diskMap)
	ctx, cancel := getContextWithCancel()
	defer cancel()

	// Invalidate the cache right after updating
	defer func() {
		_ = as.cloud.vmCache.Delete(vmName)
	}()

	rerr := as.VirtualMachinesClient.Update(ctx, nodeResourceGroup, vmName, newVM, "detach_disk")
	if rerr != nil {
		klog.Errorf("azureDisk - detach disk list(%s) on rg(%s) vm(%s) failed, err: %v", diskMap, nodeResourceGroup, vmName, rerr)
		if rerr.HTTPStatusCode == http.StatusNotFound {
			klog.Errorf("azureDisk - begin to filterNonExistingDisks(%v) on rg(%s) vm(%s)", diskMap, nodeResourceGroup, vmName)
			disks := as.filterNonExistingDisks(ctx, *vm.StorageProfile.DataDisks)
			newVM.VirtualMachineProperties.StorageProfile.DataDisks = &disks
			rerr = as.VirtualMachinesClient.Update(ctx, nodeResourceGroup, vmName, newVM, "detach_disk")
		}
	}

	klog.V(2).Infof("azureDisk - update(%s): vm(%s) - detach disk list(%s) returned with %v", nodeResourceGroup, vmName, diskMap, rerr)
	if rerr != nil {
		return rerr.Error()
	}
	return nil
}

// UpdateVM updates a vm
func (as *availabilitySet) UpdateVM(nodeName types.NodeName) error {
	vmName := mapNodeNameToVMName(nodeName)
	nodeResourceGroup, err := as.GetNodeResourceGroup(vmName)
	if err != nil {
		return err
	}
	klog.V(2).Infof("azureDisk - update(%s): vm(%s)", nodeResourceGroup, vmName)
	ctx, cancel := getContextWithCancel()
	defer cancel()

	// Invalidate the cache right after updating
	defer func() {
		_ = as.cloud.vmCache.Delete(vmName)
	}()

	rerr := as.VirtualMachinesClient.Update(ctx, nodeResourceGroup, vmName, compute.VirtualMachineUpdate{}, "update_vm")
	klog.V(2).Infof("azureDisk - update(%s): vm(%s) - returned with %v", nodeResourceGroup, vmName, rerr)
	if rerr != nil {
		return rerr.Error()
	}
	return nil
}

// GetDataDisks gets a list of data disks attached to the node.
func (as *availabilitySet) GetDataDisks(nodeName types.NodeName, crt azcache.AzureCacheReadType) ([]compute.DataDisk, *string, error) {
	vm, err := as.getVirtualMachine(nodeName, crt)
	if err != nil {
		return nil, nil, err
	}

	if vm.StorageProfile.DataDisks == nil {
		return nil, nil, nil
	}

	return *vm.StorageProfile.DataDisks, vm.ProvisioningState, nil
}


text:
#include <grpc/support/port_platform.h>

#include "src/core/lib/http/format_request.h"

#include <stdarg.h>
#include <stdio.h>
#include <string.h>

#include <vector>

#include "absl/strings/str_format.h"
#include "absl/strings/str_join.h"

#include <grpc/slice.h>
#include <grpc/support/alloc.h>
#include <grpc/support/string_util.h>

#include "src/core/lib/gpr/string.h"

static void fill_common_header(const grpc_http_request* request,
                               const char* host, const char* path,
                               bool connection_close,
                               std::vector<std::string>* buf) {
  buf->push_back(path);
  buf->push_back(" HTTP/1.1\r\n");
  buf->push_back("Host: ");
  buf->push_back(host);
  buf->push_back("\r\n");
  if (connection_close) buf->push_back("Connection: close\r\n");
  buf->push_back("User-Agent: " GRPC_HTTPCLI_USER_AGENT "\r\n");
  /* user supplied headers */
  for (size_t i = 0; i < request->hdr_count; i++) {
    buf->push_back(request->hdrs[i].key);
    buf->push_back(": ");
    buf->push_back(request->hdrs[i].value);
    buf->push_back("\r\n");
  }
}

grpc_slice grpc_httpcli_format_get_request(const grpc_http_request* request,
                                           const char* host, const char* path) {
  std::vector<std::string> out;
  out.push_back("GET ");
  fill_common_header(request, host, path, true, &out);
  out.push_back("\r\n");
  std::string req = absl::StrJoin(out, "");
  return grpc_slice_from_copied_buffer(req.data(), req.size());
}

grpc_slice grpc_httpcli_format_post_request(const grpc_http_request* request,
                                            const char* host,
                                            const char* path) {
  std::vector<std::string> out;
  out.push_back("POST ");
  fill_common_header(request, host, path, true, &out);
  if (request->body != nullptr) {
    bool has_content_type = false;
    for (size_t i = 0; i < request->hdr_count; i++) {
      if (strcmp(request->hdrs[i].key, "Content-Type") == 0) {
        has_content_type = true;
        break;
      }
    }
    if (!has_content_type) {
      out.push_back("Content-Type: text/plain\r\n");
    }
    out.push_back(
        absl::StrFormat("Content-Length: %lu\r\n",
                        static_cast<unsigned long>(request->body_length)));
  }
  out.push_back("\r\n");
  std::string req = absl::StrJoin(out, "");
  if (request->body != nullptr) {
    absl::StrAppend(&req,
                    absl::string_view(request->body, request->body_length));
  }
  return grpc_slice_from_copied_buffer(req.data(), req.size());
}

grpc_slice grpc_httpcli_format_put_request(const grpc_http_request* request,
                                           const char* host, const char* path) {
  std::vector<std::string> out;
  out.push_back("PUT ");
  fill_common_header(request, host, path, true, &out);
  if (request->body != nullptr) {
    bool has_content_type = false;
    for (size_t i = 0; i < request->hdr_count; i++) {
      if (strcmp(request->hdrs[i].key, "Content-Type") == 0) {
        has_content_type = true;
        break;
      }
    }
    if (!has_content_type) {
      out.push_back("Content-Type: text/plain\r\n");
    }
    out.push_back(
        absl::StrFormat("Content-Length: %lu\r\n",
                        static_cast<unsigned long>(request->body_length)));
  }
  out.push_back("\r\n");
  std::string req = absl::StrJoin(out, "");
  if (request->body != nullptr) {
    absl::StrAppend(&req,
                    absl::string_view(request->body, request->body_length));
  }
  return grpc_slice_from_copied_buffer(req.data(), req.size());
}

grpc_slice grpc_httpcli_format_connect_request(const grpc_http_request* request,
                                               const char* host,
                                               const char* path) {
  std::vector<std::string> out;
  out.push_back("CONNECT ");
  fill_common_header(request, host, path, false, &out);
  out.push_back("\r\n");
  std::string req = absl::StrJoin(out, "");
  return grpc_slice_from_copied_buffer(req.data(), req.size());
}


text:
import ftfy
import multiprocessing as mp
import os
import time
import re
import json
import fnmatch

# Based on code from http://www.blopig.com/blog/2016/08/processing-large-files-using-python/ by Alistair Martin
# Warning: as of yet this cleaner can only take 1 GB input files max, though will read through however many you give it
# Recommendation: Use fsplit or similar software.

def jsonCleaner(jsonl, filter, writeList, count):
    """Reads and cleans the JSONL input files."""

    for jsonFile in jsonl:
        try:
            # loads the line as a dictionary
            d = json.loads(jsonFile, encoding="utf-8")
            body = d["body"]
            # deletes URLs
            body = re.sub(r'https?:\/\/.*[\r\n]*', '', body, flags=re.MULTILINE)
            # fixes any unicode encoding errors
            body = ftfy.fix_text(body)
            # deletes chosen punctuation
            body = body.translate(filter)
            body = body.lower()
            # eliminates empty, deleted or removed comments
            if re.search('[a-z]', body) \
                    and body != " removed " \
                    and body != " deleted " \
                    and "your submission has been automatically removed" not in body \
                    and d["author"] != "AutoModerator":
                # this line can be changed to include subreddits or other pieces of data in addition to the comment body
                writeList.append("{}\n".format(body))
                count += 1
            # every 500 000th line it will spit out the 10 most recent comments
            if count == 500000:
                print(writeList[-10:])
                count = 0
        # handles invalid dictionaries
        except ValueError:
            print("Decoding Error")

def textCleaner(text, filter, writeList, count):
    for line in text:
        # deletes URLs
        line = re.sub(r'https?:\/\/.*[\r\n]*', '', line, flags=re.MULTILINE)
        # fixes unicode encoding errors
        line = ftfy.fix_text(line)
        # deletes chosen punctuation
        line = line.translate(filter)
        line = line.lower()
        if re.search('[a-z]', line):
            writeList.append(line + "\n")
            count += 1
        if count == 500000:
            print(writeList[-10:])
            count = 0

def process_wrapper(chunkStart, chunkSize, inputFile):
    # custom translation table to ensure desired punctuation is removed
    punctuation = "–~`!@#$%^&*,;.?:\/]}[{()\"_\\>|<+=\n\r"
    replace = "                                  "
    writeList = []
    count = 0
    transtable = str.maketrans(punctuation, replace)
    with open("inputFiles\\" + inputFile, encoding="utf-8-sig") as f:
        # finds the start of the file chunk
        f.seek(chunkStart)
        # reads the file chunk, spliting it by line
        lines = f.read(chunkSize).splitlines()
        # if inputFile ends in .jsonl, run jsonCleaner
        if fnmatch.fnmatch(inputFile, '*.jsonl'):
            jsonCleaner(lines, transtable, writeList, count)
        # elif inputFile ends in .txt, run textCleaner
        elif fnmatch.fnmatch(inputFile, '*.txt'):
            textCleaner(lines, transtable, writeList, count)
        with open("Feb2017.txt", "a", encoding="utf-8") as w:
            for element in writeList:
                w.write(element)

def chunkify(fname, size=10000000*1024):
    fileEnd = os.path.getsize(fname)
    with open(fname,'r') as f:
        chunkEnd = f.tell()
        while True:
            chunkStart = chunkEnd
            f.seek(size, 0)
            f.readline()
            chunkEnd = f.tell()
            yield chunkStart, chunkEnd - chunkStart
            if chunkEnd > fileEnd:
                break

startTimeClean = time.time()
listOfFiles = os.listdir("inputFiles")

if __name__ == '__main__':
    mp.freeze_support()
    #init objects
    pool = mp.Pool(4)
    jobs = []
    for inputFile in listOfFiles:
        #create jobs

        for chunkStart,chunkSize in chunkify("inputFiles\\" + inputFile):
            jobs.append(pool.apply_async(process_wrapper,(chunkStart,chunkSize, inputFile)) )

        #wait for all jobs to finish
        for job in jobs:
            job.get()

    #clean up
    pool.close()

    #timekeeping
    seconds = (time.time() - startTimeClean)
    minutes = int(seconds/60)
    seconds %= 60
    print("The program cleaned the files in {} minutes and {} seconds.".format(minutes, round(seconds, 2)))