text:
package javax.sound.sampled;

import java.util.Arrays;

/**
 * {@code DataLine} adds media-related functionality to its superinterface,
 * {@code Line}. This functionality includes transport-control methods that
 * start, stop, drain, and flush the audio data that passes through the line. A
 * data line can also report the current position, volume, and audio format of
 * the media. Data lines are used for output of audio by means of the
 * subinterfaces {@link SourceDataLine} or {@link Clip}, which allow an
 * application program to write data. Similarly, audio input is handled by the
 * subinterface {@link TargetDataLine}, which allows data to be read.
 *

 * A data line has an internal buffer in which the incoming or outgoing audio
 * data is queued. The {@link #drain()} method blocks until this internal buffer
 * becomes empty, usually because all queued data has been processed. The
 * {@link #flush()} method discards any available queued data from the internal
 * buffer.
 *

 * A data line produces {@link LineEvent.Type#START START} and
 * {@link LineEvent.Type#STOP STOP} events whenever it begins or ceases active
 * presentation or capture of data. These events can be generated in response to
 * specific requests, or as a result of less direct state changes. For example,
 * if {@link #start()} is called on an inactive data line, and data is available
 * for capture or playback, a {@code START} event will be generated shortly,
 * when data playback or capture actually begins. Or, if the flow of data to an
 * active data line is constricted so that a gap occurs in the presentation of
 * data, a {@code STOP} event is generated.
 *

 * Mixers often support synchronized control of multiple data lines.
 * Synchronization can be established through the {@code Mixer} interface's
 * {@link Mixer#synchronize synchronize} method. See the description of the
 * {@link Mixer Mixer} interface for a more complete description.
 *
 * @author Kara Kytle
 * @see LineEvent
 * @since 1.3
 */
public interface DataLine extends Line {

    /**
     * Drains queued data from the line by continuing data I/O until the data
     * line's internal buffer has been emptied. This method blocks until the
     * draining is complete. Because this is a blocking method, it should be
     * used with care. If {@code drain()} is invoked on a stopped line that has
     * data in its queue, the method will block until the line is running and
     * the data queue becomes empty. If {@code drain()} is invoked by one
     * thread, and another continues to fill the data queue, the operation will
     * not complete. This method always returns when the data line is closed.
     *
     * @see #flush()
     */
    void drain();

    /**
     * Flushes queued data from the line. The flushed data is discarded. In some
     * cases, not all queued data can be discarded. For example, a mixer can
     * flush data from the buffer for a specific input line, but any unplayed
     * data already in the output buffer (the result of the mix) will still be
     * played. You can invoke this method after pausing a line (the normal case)
     * if you want to skip the "stale" data when you restart playback or
     * capture. (It is legal to flush a line that is not stopped, but doing so
     * on an active line is likely to cause a discontinuity in the data,
     * resulting in a perceptible click.)
     *
     * @see #stop()
     * @see #drain()
     */
    void flush();

    /**
     * Allows a line to engage in data I/O. If invoked on a line that is already
     * running, this method does nothing. Unless the data in the buffer has been
     * flushed, the line resumes I/O starting with the first frame that was
     * unprocessed at the time the line was stopped. When audio capture or
     * playback starts, a {@link LineEvent.Type#START START} event is generated.
     *
     * @see #stop()
     * @see #isRunning()
     * @see LineEvent
     */
    void start();

    /**
     * Stops the line. A stopped line should cease I/O activity. If the line is
     * open and running, however, it should retain the resources required to
     * resume activity. A stopped line should retain any audio data in its
     * buffer instead of discarding it, so that upon resumption the I/O can
     * continue where it left off, if possible. (This doesn't guarantee that
     * there will never be discontinuities beyond the current buffer, of course;
     * if the stopped condition continues for too long, input or output samples
     * might be dropped.) If desired, the retained data can be discarded by
     * invoking the {@code flush} method. When audio capture or playback stops,
     * a {@link LineEvent.Type#STOP STOP} event is generated.
     *
     * @see #start()
     * @see #isRunning()
     * @see #flush()
     * @see LineEvent
     */
    void stop();

    /**
     * Indicates whether the line is running. The default is {@code false}. An
     * open line begins running when the first data is presented in response to
     * an invocation of the {@code start} method, and continues until
     * presentation ceases in response to a call to {@code stop} or because
     * playback completes.
     *
     * @return {@code true} if the line is running, otherwise {@code false}
     * @see #start()
     * @see #stop()
     */
    boolean isRunning();

    /**
     * Indicates whether the line is engaging in active I/O (such as playback or
     * capture). When an inactive line becomes active, it sends a
     * {@link LineEvent.Type#START START} event to its listeners. Similarly,
     * when an active line becomes inactive, it sends a
     * {@link LineEvent.Type#STOP STOP} event.
     *
     * @return {@code true} if the line is actively capturing or rendering
     *         sound, otherwise {@code false}
     * @see #isOpen
     * @see #addLineListener
     * @see #removeLineListener
     * @see LineEvent
     * @see LineListener
     */
    boolean isActive();

    /**
     * Obtains the current format (encoding, sample rate, number of channels,
     * etc.) of the data line's audio data.
     *

     * If the line is not open and has never been opened, it returns the default
     * format. The default format is an implementation specific audio format,
     * or, if the {@code DataLine.Info} object, which was used to retrieve this
     * {@code DataLine}, specifies at least one fully qualified audio format,
     * the last one will be used as the default format. Opening the line with a
     * specific audio format (e.g. {@link SourceDataLine#open(AudioFormat)})
     * will override the default format.
     *
     * @return current audio data format
     * @see AudioFormat
     */
    AudioFormat getFormat();

    /**
     * Obtains the maximum number of bytes of data that will fit in the data
     * line's internal buffer. For a source data line, this is the size of the
     * buffer to which data can be written. For a target data line, it is the
     * size of the buffer from which data can be read. Note that the units used
     * are bytes, but will always correspond to an integral number of sample
     * frames of audio data.
     *
     * @return the size of the buffer, in bytes
     */
    int getBufferSize();

    /**
     * Obtains the number of bytes of data currently available to the
     * application for processing in the data line's internal buffer. For a
     * source data line, this is the amount of data that can be written to the
     * buffer without blocking. For a target data line, this is the amount of
     * data available to be read by the application. For a clip, this value is
     * always 0 because the audio data is loaded into the buffer when the clip
     * is opened, and persists without modification until the clip is closed.
     *

     * Note that the units used are bytes, but will always correspond to an
     * integral number of sample frames of audio data.
     *

     * An application is guaranteed that a read or write operation of up to the
     * number of bytes returned from {@code available()} will not block;
     * however, there is no guarantee that attempts to read or write more data
     * will block.
     *
     * @return the amount of data available, in bytes
     */
    int available();

    /**
     * Obtains the current position in the audio data, in sample frames. The
     * frame position measures the number of sample frames captured by, or
     * rendered from, the line since it was opened. This return value will wrap
     * around after 2^31 frames. It is recommended to use
     * {@code getLongFramePosition} instead.
     *
     * @return the number of frames already processed since the line was opened
     * @see #getLongFramePosition()
     */
    int getFramePosition();

    /**
     * Obtains the current position in the audio data, in sample frames. The
     * frame position measures the number of sample frames captured by, or
     * rendered from, the line since it was opened.
     *
     * @return the number of frames already processed since the line was opened
     * @since 1.5
     */
    long getLongFramePosition();

    /**
     * Obtains the current position in the audio data, in microseconds. The
     * microsecond position measures the time corresponding to the number of
     * sample frames captured by, or rendered from, the line since it was
     * opened. The level of precision is not guaranteed. For example, an
     * implementation might calculate the microsecond position from the current
     * frame position and the audio sample frame rate. The precision in
     * microseconds would then be limited to the number of microseconds per
     * sample frame.
     *
     * @return the number of microseconds of data processed since the line was
     *         opened
     */
    long getMicrosecondPosition();

    /**
     * Obtains the current volume level for the line. This level is a measure of
     * the signal's current amplitude, and should not be confused with the
     * current setting of a gain control. The range is from 0.0 (silence) to 1.0
     * (maximum possible amplitude for the sound waveform). The units measure
     * linear amplitude, not decibels.
     *
     * @return the current amplitude of the signal in this line, or
     *         {@link AudioSystem#NOT_SPECIFIED}
     */
    float getLevel();

    /**
     * Besides the class information inherited from its superclass,
     * {@code DataLine.Info} provides additional information specific to data
     * lines. This information includes:
     *

     *
the audio formats supported by the data line
     *
the minimum and maximum sizes of its internal buffer
     *

     * Because a {@code Line.Info} knows the class of the line its describes, a
     * {@code DataLine.Info} object can describe {@code DataLine} subinterfaces
     * such as {@link SourceDataLine}, {@link TargetDataLine}, and {@link Clip}.
     * You can query a mixer for lines of any of these types, passing an
     * appropriate instance of {@code DataLine.Info} as the argument to a method
     * such as {@link Mixer#getLine(Line.Info)}.
     *
     * @author Kara Kytle
     * @see Line.Info
     * @since 1.3
     */
    class Info extends Line.Info {

        /**
         * The set of supported formats.
         */
        private final AudioFormat[] formats;

        /**
         * Minimum buffer size supported by the data line, in bytes.
         */
        private final int minBufferSize;

        /**
         * Maximum buffer size supported by the data line, in bytes.
         */
        private final int maxBufferSize;

        /**
         * Constructs a data line's info object from the specified information,
         * which includes a set of supported audio formats and a range for the
         * buffer size. This constructor is typically used by mixer
         * implementations when returning information about a supported line.
         *
         * @param  lineClass the class of the data line described by the info
         *         object
         * @param  formats set of formats supported
         * @param  minBufferSize minimum buffer size supported by the data line,
         *         in bytes
         * @param  maxBufferSize maximum buffer size supported by the data line,
         *         in bytes
         */
        public Info(Class<?> lineClass, AudioFormat[] formats, int minBufferSize, int maxBufferSize) {

            super(lineClass);

            if (formats == null) {
                this.formats = new AudioFormat[0];
            } else {
                this.formats = Arrays.copyOf(formats, formats.length);
            }

            this.minBufferSize = minBufferSize;
            this.maxBufferSize = maxBufferSize;
        }

        /**
         * Constructs a data line's info object from the specified information,
         * which includes a single audio format and a desired buffer size. This
         * constructor is typically used by an application to describe a desired
         * line.
         *
         * @param  lineClass the class of the data line described by the info
         *         object
         * @param  format desired format
         * @param  bufferSize desired buffer size, in bytes
         */
        public Info(Class<?> lineClass, AudioFormat format, int bufferSize) {

            super(lineClass);

            if (format == null) {
                this.formats = new AudioFormat[0];
            } else {
                this.formats = new AudioFormat[]{format};
            }

            this.minBufferSize = bufferSize;
            this.maxBufferSize = bufferSize;
        }

        /**
         * Constructs a data line's info object from the specified information,
         * which includes a single audio format. This constructor is typically
         * used by an application to describe a desired line.
         *
         * @param  lineClass the class of the data line described by the info
         *         object
         * @param  format desired format
         */
        public Info(Class<?> lineClass, AudioFormat format) {
            this(lineClass, format, AudioSystem.NOT_SPECIFIED);
        }

        /**
         * Obtains a set of audio formats supported by the data line. Note that
         * {@code isFormatSupported(AudioFormat)} might return {@code true} for
         * certain additional formats that are missing from the set returned by
         * {@code getFormats()}. The reverse is not the case:
         * {@code isFormatSupported(AudioFormat)} is guaranteed to return
         * {@code true} for all formats returned by {@code getFormats()}.
         *

         * Some fields in the {@code AudioFormat} instances can be set to
         * {@link AudioSystem#NOT_SPECIFIED NOT_SPECIFIED} if that field does
         * not apply to the format, or if the format supports a wide range of
         * values for that field. For example, a multi-channel device supporting
         * up to 64 channels, could set the channel field in the
         * {@code AudioFormat} instances returned by this method to
         * {@code NOT_SPECIFIED}.
         *
         * @return a set of supported audio formats
         * @see #isFormatSupported(AudioFormat)
         */
        public AudioFormat[] getFormats() {
            return Arrays.copyOf(formats, formats.length);
        }

        /**
         * Indicates whether this data line supports a particular audio format.
         * The default implementation of this method simply returns {@code true}
         * if the specified format matches any of the supported formats.
         *
         * @param  format the audio format for which support is queried
         * @return {@code true} if the format is supported, otherwise
         *         {@code false}
         * @see #getFormats
         * @see AudioFormat#matches
         */
        public boolean isFormatSupported(AudioFormat format) {

            for (int i = 0; i < formats.length; i++) {
                if (format.matches(formats[i])) {
                    return true;
                }
            }

            return false;
        }

        /**
         * Obtains the minimum buffer size supported by the data line.
         *
         * @return minimum buffer size in bytes, or
         *         {@code AudioSystem.NOT_SPECIFIED}
         */
        public int getMinBufferSize() {
            return minBufferSize;
        }

        /**
         * Obtains the maximum buffer size supported by the data line.
         *
         * @return maximum buffer size in bytes, or
         *         {@code AudioSystem.NOT_SPECIFIED}
         */
        public int getMaxBufferSize() {
            return maxBufferSize;
        }

        /**
         * Determines whether the specified info object matches this one. To
         * match, the superclass match requirements must be met. In addition,
         * this object's minimum buffer size must be at least as large as that
         * of the object specified, its maximum buffer size must be at most as
         * large as that of the object specified, and all of its formats must
         * match formats supported by the object specified.
         *
         * @param  info the info object which is being compared to this one
         * @return {@code true} if this object matches the one specified,
         *         otherwise {@code false}
         */
        @Override
        public boolean matches(Line.Info info) {

            if (! (super.matches(info)) ) {
                return false;
            }

            Info dataLineInfo = (Info)info;

            // treat anything < 0 as NOT_SPECIFIED
            // demo code in old Java Sound Demo used a wrong buffer calculation
            // that would lead to arbitrary negative values
            if ((getMaxBufferSize() >= 0) && (dataLineInfo.getMaxBufferSize() >= 0)) {
                if (getMaxBufferSize() > dataLineInfo.getMaxBufferSize()) {
                    return false;
                }
            }

            if ((getMinBufferSize() >= 0) && (dataLineInfo.getMinBufferSize() >= 0)) {
                if (getMinBufferSize() < dataLineInfo.getMinBufferSize()) {
                    return false;
                }
            }

            AudioFormat[] localFormats = getFormats();

            if (localFormats != null) {

                for (int i = 0; i < localFormats.length; i++) {
                    if (! (localFormats[i] == null) ) {
                        if (! (dataLineInfo.isFormatSupported(localFormats[i])) ) {
                            return false;
                        }
                    }
                }
            }

            return true;
        }

        /**
         * Returns a string representation of the info object.
         *
         * @return a string representation of the info object
         */
        @Override
        public String toString() {
            String format = "";
            AudioFormat[] formats = getFormats();
            if (formats.length == 1 && formats[0] != null) {
                format = " supporting format " + formats[0];
            } else if (formats.length > 1) {
                format = " supporting " + formats.length + " audio formats";
            }

            String buffers = "";
            int min = getMinBufferSize();
            int max = getMaxBufferSize();
            if (min != AudioSystem.NOT_SPECIFIED
                    && max != AudioSystem.NOT_SPECIFIED) {
                buffers = ", and buffers of " + min + " to " + max + " bytes";
            } else if (min > 0) {
                buffers = ", and buffers of at least " + min + " bytes";
            } else if (max != AudioSystem.NOT_SPECIFIED) {
                buffers = ", and buffers of up to " + max + " bytes";
            }

            return String.format("%s%s%s", super.toString(), format, buffers);
        }
    }
}


text:
package quasar.connector

import quasar.Disposable
import quasar.api.datasource.DatasourceType
import quasar.api.datasource.DatasourceError.InitializationError
import quasar.api.resource.ResourcePath
import quasar.qscript.InterpretedRead

import scala.concurrent.ExecutionContext

import argonaut.Json
import cats.effect.{ConcurrentEffect, ContextShift, Timer}
import fs2.Stream
import scalaz.\/

trait LightweightDatasourceModule {
  type DS[F[_]] = Datasource[F, Stream[F, ?], InterpretedRead[ResourcePath], QueryResult[F]]

  def kind: DatasourceType

  def sanitizeConfig(config: Json): Json

  def lightweightDatasource[F[_]: ConcurrentEffect: ContextShift: MonadResourceErr: Timer](
      config: Json)(
      implicit ec: ExecutionContext)
      : F[InitializationError[Json] \/ Disposable[F, DS[F]]]
}

redpajama_set_name: RedPajamaGithub


text:
function limparCamposFotoPerfil() {
    $("#idFotoPerfil").val('');
    $("#idAlbumFotoPerfil").val(top.idAlbum);
    $("#tpFotoPerfil").val('1');
    $("#stFotoPerfil").val('1');
    $("#stComentarioFotoPerfil").val('1');
    $("#dsLegendaFotoPerfil").val('');
    $("#dsArquivoFotoPerfil").val('');
    $('#imgFotoPerfil').attr("src", top.basePath + "/epona/images/demo/people/9.jpg");
    abrirFecharLinkFileFotoPerfil();
}

function carregarCamposFotoPerfil(json) {
    $("#idFotoPerfil").val(json.idFoto);
    $("#idAlbumFotoPerfil").val(json.idAlbum);
    $("#tpFotoPerfil").val(json.tpFoto);
    $("#stFotoPerfil").val(json.stFoto);
    $("#stComentarioFotoPerfil").val(json.stComentario);
    $("#dsLegendaFotoPerfil").val(json.dsLegenda);
    $("#dsArquivoFotoPerfil").val(json.dsArquivo);
    $('#imgFotoPerfil').attr("src", top.basePath + "/storage/fotos/" + top.idCliente + "/"  + json.idAlbum + "/" + json.dsArquivo);
    $('#filenameFotoPerfil').html('Arquivo: ' + json.dsArquivo + '');
    abrirFecharLinkFileFotoPerfil();
}

function selecionarFotoPerfil(idFotoPerfil) {
    var url = top.basePath + '/album-foto/foto/selecionar';
    $.ajax({
        type: "POST",
        url: url,
        data: {
            idFoto: idFotoPerfil
        },
        dataType: "json",
        success: function (data) {
            limparCamposFotoPerfil();
            if (data.tipoMsg === "S") {
                carregarCamposFotoPerfil(data);
            }
            $('#carregando').hide();
        }
    });
}

function validarCamposFotoPerfil() {
    var chk = true;
    var texto = "
";

    if ($("#dsArquivoFotoPerfil").val() === "") {
        if ($("#fileFotoPerfil").val() === "") {
            texto += "
O campo \"Arquivo\" é de preechimento obrigatório.
";
            chk = false;
        }
    }

    texto += "
";

    if (chk === false) {
        Componentes.modalAlerta(texto, null);
        return chk;
    } else {
        return chk;
    }
}

function salvarFotoPerfil() {
    if (validarCamposFotoPerfil()) {
        $('#carregando').show();
        var postData = $('#formCadFotoPerfil').serializeArray();
        var formURL = top.basePath + '/album-foto/foto/salvar-foto-perfil';
        $.ajax({
            type: "POST",
            url: formURL,
            data: postData,
            dataType: "json",
            success: function (data) {
                if (data.tipoMsg === "S") {
                    selecionarFotoPerfil(data.idFoto);
                } else {
                    Componentes.modalAlerta(formataTextMsg(data.textoMsg), null);
                }
            }
        });
    }
}

function confirmarRemoverArquivoFotoPerfil() {
    top.nameFile = $("#dsArquivoFotoPerfil").val();
    Componentes.modalConfirmacao(null, 'Tem certeza que deseja remover esse arquivo?', removerArquivoFotoPerfil, null);
}

function removerArquivoFotoPerfil() {
    $('#carregando').show();
    var formURL = top.basePath + "/album-foto/foto/remover-arquivo";
    $.ajax({
        type: "POST",
        url: formURL,
        data: {
                idCliente: top.idCliente,
                idAlbum: top.idAlbum,
                nameFile: top.nameFile
                },
        dataType: "json",
        success: function (data) {
            $('#carregando').hide();
            $('#modalConfirmacao').modal('hide');
            top.nameFile = null;
            if (data.tipoMsg !== "S") {
                Componentes.modalAlerta(data.textoMsg, null);
            }
            $('#imgFotoPerfil').attr("src", top.basePath + "/epona/images/demo/people/9.jpg");
            $("#dsArquivoFotoPerfil").val('');
            abrirFecharLinkFileFotoPerfil();
        }
    });
}

function abrirFecharLinkFileFotoPerfil() {
    if ($("#dsArquivoFotoPerfil").val() !== "") {
        $('#divFileFotoPerfil').hide();
        $('#divLinkFotoPerfil').show();
    } else {
        $('#divFileFotoPerfil').show();
        $('#divLinkFotoPerfil').hide();
    }
}

function verificarFotoPerfil() {
    limparCamposFotoPerfil();
    var postData = $('#formCadFotoPerfil').serializeArray();
    var url = top.basePath + '/album-foto/foto/verificar-foto-perfil';
    $.ajax({
        type: "POST",
        url: url,
        data: postData,
        dataType: "json",
        success: function (data) {
            if (data.tipoMsg === "S") {
                selecionarFotoPerfil(data.idFoto);
            }
        }
    });
}

$(document).ready(function () {
    if (top.idClientePerfil !== undefined) {
        $('#divBtnRemoverFotoPerfil').hide();
        $('#divNotaFotoPerfil').hide();
        $('#divBtnsFotoPerfil').hide();
    }

    $('#btnRemoverArquivoFotoPerfil').on('click', function () {
        confirmarRemoverArquivoFotoPerfil();
    });

    $('#btnGravarFotoPerfil').on('click', function () {
        salvarFotoPerfil();
    });

    $('#fileFotoPerfil').change(function() {
        $(this).simpleUpload(top.basePath + "/album-foto/foto/upload", {
            allowedExts: ["jpg", "jpeg", "jpe", "jif", "jfif", "jfi", "png", "gif"],
            allowedTypes: ["image/pjpeg", "image/jpeg", "image/png", "image/x-png", "image/gif", "image/x-gif"],
            maxFileSize: 25000000,
            start: function(){
                $('#carregando').show();
            },
            progress: function(progress){
                console.log("upload progress: " + Math.round(progress) + "%");
            },
            success: function(data){
                $('#carregando').hide();
                if (data.tipoMsg !== "S") {
                    Componentes.modalAlerta(formataTextMsg("Falha no upload!
Data: " + JSON.stringify(data.textoMsg)), null);
                    $("#dsArquivoFotoCapa").val('');
                } else {
                    $('#filenameFotoPerfil').html('Arquivo: ' + data.name + '');
                    $('#imgFotoPerfil').attr("src", top.basePath + "/storage/fotos/" + top.idCliente + "/"  + top.idAlbum + "/" + data.name);
                    $("#dsArquivoFotoPerfil").val(data.name);
                }
                abrirFecharLinkFileFotoPerfil();
            },
            error: function(error){
                Componentes.modalAlerta(formataTextMsg("Falha no upload!
" + error.name + ": " + error.message), null);
                $("#dsArquivoFotoPerfil").val('');
                abrirFecharLinkFileFotoPerfil();
            }
        });
    });
});


text:
package org.apache.drill.exec.store.http;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder;
import org.apache.drill.common.PlanStringBuilder;
import org.apache.drill.exec.record.metadata.TupleMetadata;
import org.apache.drill.exec.store.easy.json.config.JsonConfigOptions;
import java.util.Objects;

@JsonInclude(JsonInclude.Include.NON_DEFAULT)
@JsonDeserialize(builder = HttpJsonOptions.HttpJsonOptionsBuilder.class)
public class HttpJsonOptions extends JsonConfigOptions {
  @JsonProperty
  private final TupleMetadata schema;

  HttpJsonOptions(HttpJsonOptionsBuilder builder) {
    super(builder.allowNanInf, builder.allTextMode, builder.readNumbersAsDouble, builder.enableEscapeAnyChar, builder.skipMalformedDocument, builder.skipMalformedRecords);
    this.schema = builder.schema;
  }

  public static HttpJsonOptionsBuilder builder() {
    return new HttpJsonOptionsBuilder();
  }

  @JsonProperty("schema")
  public TupleMetadata schema() {
    return this.schema;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    HttpJsonOptions that = (HttpJsonOptions) o;
    return Objects.equals(allowNanInf, that.allowNanInf)
      && Objects.equals(allTextMode, that.allTextMode)
      && Objects.equals(readNumbersAsDouble, that.readNumbersAsDouble)
      && Objects.equals(enableEscapeAnyChar, that.enableEscapeAnyChar)
      && Objects.equals(skipMalformedDocument, that.skipMalformedDocument)
      && Objects.equals(skipMalformedRecords, that.skipMalformedRecords)
      && Objects.equals(schema, that.schema);
  }

  @Override
  public int hashCode() {
    return Objects.hash(allowNanInf, allTextMode, readNumbersAsDouble, enableEscapeAnyChar, skipMalformedDocument, skipMalformedRecords, schema);
  }

  @Override
  public String toString() {
    return new PlanStringBuilder(this)
      .field("allowNanInf", allowNanInf)
      .field("allTextMode", allTextMode)
      .field("readNumbersAsDouble", readNumbersAsDouble)
      .field("enableEscapeAnyChar", enableEscapeAnyChar)
      .field("skipMalformedRecords", skipMalformedRecords)
      .field("skipMalformedDocument", skipMalformedDocument)
      .field("schema", schema)
      .toString();
  }

  @JsonPOJOBuilder(withPrefix = "")
  public static class HttpJsonOptionsBuilder extends JsonConfigOptionsBuilder {
    private TupleMetadata schema;

    public HttpJsonOptionsBuilder schema(TupleMetadata schema) {
      this.schema = schema;
      return this;
    }

    public HttpJsonOptionsBuilder allTextMode(Boolean allTextMode) {
      super.allTextMode(allTextMode);
      return this;
    }

    public HttpJsonOptionsBuilder allowNanInf(Boolean allowNanInf) {
      super.allowNanInf(allowNanInf);
      return this;
    }

    public HttpJsonOptionsBuilder enableEscapeAnyChar(Boolean enableEscapeAnyChar) {
      super.enableEscapeAnyChar(enableEscapeAnyChar);
      return this;
    }

    public HttpJsonOptionsBuilder readNumbersAsDouble(Boolean readNumbersAsDouble) {
      super.readNumbersAsDouble(readNumbersAsDouble);
      return this;
    }

    public HttpJsonOptionsBuilder skipMalformedRecords(Boolean skipMalformedRecords) {
      super.skipMalformedRecords(skipMalformedRecords);
      return this;
    }

    public HttpJsonOptionsBuilder skipMalformedDocument(Boolean skipMalformedDocument) {
      super.skipMalformedDocument(skipMalformedDocument);
      return this;
    }

    public HttpJsonOptions build() {
      return new HttpJsonOptions(this);
    }
  }
}


text:
import {NgModule} from '@angular/core';
import {OverlayModule} from '@angular/cdk/overlay';

import {CdkOverlayBasicExample} from './cdk-overlay-basic/cdk-overlay-basic-example';

export {CdkOverlayBasicExample};

const EXAMPLES = [CdkOverlayBasicExample];

@NgModule({
  imports: [OverlayModule],
  declarations: EXAMPLES,
  exports: EXAMPLES,
  entryComponents: EXAMPLES,
})
export class CdkOverlayExamplesModule {}


text:
#include <aws/codeartifact/model/DomainDescription.h>
#include <aws/core/utils/json/JsonSerializer.h>

#include <utility>

using namespace Aws::Utils::Json;
using namespace Aws::Utils;

namespace Aws
{
namespace CodeArtifact
{
namespace Model
{

DomainDescription::DomainDescription() :
    m_nameHasBeenSet(false),
    m_ownerHasBeenSet(false),
    m_arnHasBeenSet(false),
    m_status(DomainStatus::NOT_SET),
    m_statusHasBeenSet(false),
    m_createdTimeHasBeenSet(false),
    m_encryptionKeyHasBeenSet(false),
    m_repositoryCount(0),
    m_repositoryCountHasBeenSet(false),
    m_assetSizeBytes(0),
    m_assetSizeBytesHasBeenSet(false),
    m_s3BucketArnHasBeenSet(false)
{
}

DomainDescription::DomainDescription(JsonView jsonValue) :
    m_nameHasBeenSet(false),
    m_ownerHasBeenSet(false),
    m_arnHasBeenSet(false),
    m_status(DomainStatus::NOT_SET),
    m_statusHasBeenSet(false),
    m_createdTimeHasBeenSet(false),
    m_encryptionKeyHasBeenSet(false),
    m_repositoryCount(0),
    m_repositoryCountHasBeenSet(false),
    m_assetSizeBytes(0),
    m_assetSizeBytesHasBeenSet(false),
    m_s3BucketArnHasBeenSet(false)
{
  *this = jsonValue;
}

DomainDescription& DomainDescription::operator =(JsonView jsonValue)
{
  if(jsonValue.ValueExists("name"))
  {
    m_name = jsonValue.GetString("name");

    m_nameHasBeenSet = true;
  }

  if(jsonValue.ValueExists("owner"))
  {
    m_owner = jsonValue.GetString("owner");

    m_ownerHasBeenSet = true;
  }

  if(jsonValue.ValueExists("arn"))
  {
    m_arn = jsonValue.GetString("arn");

    m_arnHasBeenSet = true;
  }

  if(jsonValue.ValueExists("status"))
  {
    m_status = DomainStatusMapper::GetDomainStatusForName(jsonValue.GetString("status"));

    m_statusHasBeenSet = true;
  }

  if(jsonValue.ValueExists("createdTime"))
  {
    m_createdTime = jsonValue.GetDouble("createdTime");

    m_createdTimeHasBeenSet = true;
  }

  if(jsonValue.ValueExists("encryptionKey"))
  {
    m_encryptionKey = jsonValue.GetString("encryptionKey");

    m_encryptionKeyHasBeenSet = true;
  }

  if(jsonValue.ValueExists("repositoryCount"))
  {
    m_repositoryCount = jsonValue.GetInteger("repositoryCount");

    m_repositoryCountHasBeenSet = true;
  }

  if(jsonValue.ValueExists("assetSizeBytes"))
  {
    m_assetSizeBytes = jsonValue.GetInt64("assetSizeBytes");

    m_assetSizeBytesHasBeenSet = true;
  }

  if(jsonValue.ValueExists("s3BucketArn"))
  {
    m_s3BucketArn = jsonValue.GetString("s3BucketArn");

    m_s3BucketArnHasBeenSet = true;
  }

  return *this;
}

JsonValue DomainDescription::Jsonize() const
{
  JsonValue payload;

  if(m_nameHasBeenSet)
  {
   payload.WithString("name", m_name);

  }

  if(m_ownerHasBeenSet)
  {
   payload.WithString("owner", m_owner);

  }

  if(m_arnHasBeenSet)
  {
   payload.WithString("arn", m_arn);

  }

  if(m_statusHasBeenSet)
  {
   payload.WithString("status", DomainStatusMapper::GetNameForDomainStatus(m_status));
  }

  if(m_createdTimeHasBeenSet)
  {
   payload.WithDouble("createdTime", m_createdTime.SecondsWithMSPrecision());
  }

  if(m_encryptionKeyHasBeenSet)
  {
   payload.WithString("encryptionKey", m_encryptionKey);

  }

  if(m_repositoryCountHasBeenSet)
  {
   payload.WithInteger("repositoryCount", m_repositoryCount);

  }

  if(m_assetSizeBytesHasBeenSet)
  {
   payload.WithInt64("assetSizeBytes", m_assetSizeBytes);

  }

  if(m_s3BucketArnHasBeenSet)
  {
   payload.WithString("s3BucketArn", m_s3BucketArn);

  }

  return payload;
}

} // namespace Model
} // namespace CodeArtifact
} // namespace Aws


text:
"""This is the setup file for the project. The standard setup rules apply:

   python setup.py build
   sudo python setup.py install
"""

from __future__ import print_function
import glob
import locale
import os
import sys

import run_tests

try:
  from setuptools import find_packages, setup, Command
except ImportError:
  from distutils.core import find_packages, setup, Command

# Change PYTHONPATH to include plaso.
sys.path.insert(0, u'.')

import plaso
import plaso.dependencies

version_tuple = (sys.version_info[0], sys.version_info[1])
if version_tuple < (2, 7) or version_tuple >= (3, 0):
  print((u'Unsupported Python version: {0:s}, version 2.7 or higher and '
         u'lower than 3.x required.').format(sys.version))
  sys.exit(1)

def GetScripts():
  """List up all scripts that should be runable from the command line."""
  scripts = []

  script_filenames = frozenset([
      u'image_export.py',
      u'log2timeline.py',
      u'pinfo.py',
      u'preg.py',
      u'psort.py'])

  for filename in script_filenames:
    scripts.append(os.path.join(u'tools', filename))

  return scripts

class TestCommand(Command):
  """Run tests, implementing an interface."""
  user_options = []

  def initialize_options(self):
    self._dir = os.getcwd()

  def finalize_options(self):
    pass

  def run(self):
    test_results = run_tests.RunTests()

encoding = sys.stdin.encoding

# Note that sys.stdin.encoding can be None.
if not encoding:
  encoding = locale.getpreferredencoding()

# Make sure the default encoding is set correctly otherwise
# setup.py sdist will fail to include filenames with Unicode characters.
reload(sys)
sys.setdefaultencoding(encoding)

# Unicode in the description will break python-setuptools, hence
# "Plaso Langar Að Safna Öllu" was removed.
plaso_description = (
    u'plaso is a tool designed to extract timestamps from various files found '
    u'on a typical computer system(s) and aggregate them.')

setup(
    name='plaso',
    version=plaso.GetVersion(),
    description=plaso_description,
    long_description=plaso_description,
    license='Apache License, Version 2.0',
    url='https://sites.google.com/a/kiddaland.net/plaso',
    maintainer='Plaso development team',
    maintainer_email='log2timeline-dev@googlegroups.com',
    scripts=GetScripts(),
    cmdclass={'test': TestCommand},
    classifiers=[
        'Development Status :: 4 - Beta',
        'Environment :: Console',
        'Operating System :: OS Independent',
        'Programming Language :: Python',
    ],
    packages=find_packages('.', exclude=[
        'docs', 'tests', 'tests.*', 'tools', 'utils']),
    package_dir={
        'plaso': 'plaso',
    },
    data_files=[
        ('share/plaso', glob.glob(os.path.join('data', '*'))),
        ('share/doc/plaso', [
            u'AUTHORS', u'ACKNOWLEDGEMENTS', u'LICENSE', u'README']),
    ],
    # TODO: this is disabled for now since setup.py will actually try
    # to install the depencies directly from pypi.
    # install_requires=plaso.dependencies.GetInstallRequires(),
)