text:
package org.apache.nifi.processors.standard;

import org.apache.nifi.processor.Relationship;
import org.apache.nifi.processors.standard.util.JmsFactory;
import org.apache.nifi.processors.standard.util.JmsProperties;
import org.apache.nifi.processors.standard.util.WrappedMessageProducer;
import org.apache.nifi.util.MockFlowFile;
import org.apache.nifi.util.TestRunner;
import org.apache.nifi.util.TestRunners;
import org.apache.nifi.web.Revision;
import org.junit.Test;
import org.slf4j.LoggerFactory;
import org.slf4j.impl.SimpleLogger;

import javax.jms.BytesMessage;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import javax.jms.StreamMessage;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class TestGetJMSQueue {

    @Test
    public void testSchemelessURI() throws Exception {
        String expectedErrMsg = "Failed to connect to JMS Server due to javax.jms.JMSException: "
                + "Could not create Transport. Reason: java.io.IOException: Transport not scheme specified: [localhost]";

        ByteArrayOutputStream bos = this.prepLogOutputStream();
        GetJMSQueue getJmsQueue = new GetJMSQueue();

        TestRunner runner = TestRunners.newTestRunner(getJmsQueue);
        runner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        runner.setProperty(JmsProperties.URL, "localhost");
        runner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        runner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);

        runner.run();
        assertEquals(0, runner.getFlowFilesForRelationship("success").size());
        assertTrue(bos.toString("ASCII").contains(expectedErrMsg));
    }

    @Test
    public void testPortlessURI() throws Exception {
        String expectedErrMsg = "Failed to connect to JMS Server due to javax.jms.JMSException: "
                + "Could not connect to broker URL: tcp://localhost. Reason: java.lang.IllegalArgumentException: port out of range:-1";

        ByteArrayOutputStream bos = this.prepLogOutputStream();
        GetJMSQueue getJmsQueue = new GetJMSQueue();

        TestRunner runner = TestRunners.newTestRunner(getJmsQueue);
        runner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        runner.setProperty(JmsProperties.URL, "tcp://localhost");
        runner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        runner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);

        runner.run();
        assertEquals(0, runner.getFlowFilesForRelationship("success").size());
        assertTrue(bos.toString("ASCII").contains(expectedErrMsg));
    }

    @Test
    public void testCompositeSchemelessPortlessURI() throws Exception {
        String expectedErrMsg1 = "Failed to connect to [tcp://localhost] after: 2 attempt(s)";
        String expectedErrMsg2 = "Failed to connect to JMS Server due to javax.jms.JMSException: port out of range:-1";

        ByteArrayOutputStream bos = this.prepLogOutputStream();
        GetJMSQueue getJmsQueue = new GetJMSQueue();
        TestRunner runner = TestRunners.newTestRunner(getJmsQueue);
        runner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        runner.setProperty(JmsProperties.URL,
                "failover:(tcp://localhost,remotehost)?initialReconnectDelay=1&startupMaxReconnectAttempts=2");
        runner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        runner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);

        runner.run();
        assertEquals(0, runner.getFlowFilesForRelationship("success").size());
        assertTrue(bos.toString("ASCII").contains(expectedErrMsg1));
        assertTrue(bos.toString("ASCII").contains(expectedErrMsg2));
    }

    private ByteArrayOutputStream prepLogOutputStream() throws Exception {
        LoggerFactory.getLogger(GetJMSQueue.class);
        Field field = SimpleLogger.class.getDeclaredField("TARGET_STREAM");
        field.setAccessible(true);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        field.set(null, new PrintStream(bos));
        return bos;
    }

    @Test
    public void testSendTextToQueue() throws Exception {
        PutJMS putJms = new PutJMS();
        TestRunner putRunner = TestRunners.newTestRunner(putJms);
        putRunner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        putRunner.setProperty(JmsProperties.URL, "vm://localhost?broker.persistent=false");
        putRunner.setProperty(JmsProperties.DESTINATION_TYPE, JmsProperties.DESTINATION_TYPE_QUEUE);
        putRunner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        putRunner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);

        WrappedMessageProducer wrappedProducer = JmsFactory.createMessageProducer(putRunner.getProcessContext(), true);
        final Session jmsSession = wrappedProducer.getSession();
        final MessageProducer producer = wrappedProducer.getProducer();
        final Message message = jmsSession.createTextMessage("Hello World");

        producer.send(message);
        jmsSession.commit();

        GetJMSQueue getJmsQueue = new GetJMSQueue();
        TestRunner runner = TestRunners.newTestRunner(getJmsQueue);
        runner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        runner.setProperty(JmsProperties.URL, "vm://localhost?broker.persistent=false");
        runner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        runner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);

        runner.run();

        List<MockFlowFile> flowFiles = runner
                .getFlowFilesForRelationship(new Relationship.Builder().name("success").build());

        assertTrue(flowFiles.size() == 1);
        MockFlowFile successFlowFile = flowFiles.get(0);
        successFlowFile.assertContentEquals("Hello World");
        successFlowFile.assertAttributeEquals("jms.JMSDestination", "queue.testing");
        producer.close();
        jmsSession.close();
    }

    @Test
    public void testSendBytesToQueue() throws Exception {
        PutJMS putJms = new PutJMS();
        TestRunner putRunner = TestRunners.newTestRunner(putJms);
        putRunner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        putRunner.setProperty(JmsProperties.URL, "vm://localhost?broker.persistent=false");
        putRunner.setProperty(JmsProperties.DESTINATION_TYPE, JmsProperties.DESTINATION_TYPE_QUEUE);
        putRunner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        putRunner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);
        WrappedMessageProducer wrappedProducer = JmsFactory.createMessageProducer(putRunner.getProcessContext(), true);
        final Session jmsSession = wrappedProducer.getSession();
        final MessageProducer producer = wrappedProducer.getProducer();
        final BytesMessage message = jmsSession.createBytesMessage();
        message.writeBytes("Hello Bytes".getBytes());

        producer.send(message);
        jmsSession.commit();

        GetJMSQueue getJmsQueue = new GetJMSQueue();
        TestRunner runner = TestRunners.newTestRunner(getJmsQueue);
        runner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        runner.setProperty(JmsProperties.URL, "vm://localhost?broker.persistent=false");
        runner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        runner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);

        runner.run();

        List<MockFlowFile> flowFiles = runner
                .getFlowFilesForRelationship(new Relationship.Builder().name("success").build());

        assertTrue(flowFiles.size() == 1);
        MockFlowFile successFlowFile = flowFiles.get(0);
        successFlowFile.assertContentEquals("Hello Bytes");
        successFlowFile.assertAttributeEquals("jms.JMSDestination", "queue.testing");
        producer.close();
        jmsSession.close();
    }

    @Test
    public void testSendStreamToQueue() throws Exception {
        PutJMS putJms = new PutJMS();
        TestRunner putRunner = TestRunners.newTestRunner(putJms);
        putRunner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        putRunner.setProperty(JmsProperties.URL, "vm://localhost?broker.persistent=false");
        putRunner.setProperty(JmsProperties.DESTINATION_TYPE, JmsProperties.DESTINATION_TYPE_QUEUE);
        putRunner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        putRunner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);
        WrappedMessageProducer wrappedProducer = JmsFactory.createMessageProducer(putRunner.getProcessContext(), true);
        final Session jmsSession = wrappedProducer.getSession();
        final MessageProducer producer = wrappedProducer.getProducer();

        final StreamMessage message = jmsSession.createStreamMessage();
        message.writeBytes("Hello Stream".getBytes());

        producer.send(message);
        jmsSession.commit();

        GetJMSQueue getJmsQueue = new GetJMSQueue();
        TestRunner runner = TestRunners.newTestRunner(getJmsQueue);
        runner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        runner.setProperty(JmsProperties.URL, "vm://localhost?broker.persistent=false");
        runner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        runner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);

        runner.run();

        List<MockFlowFile> flowFiles = runner
                .getFlowFilesForRelationship(new Relationship.Builder().name("success").build());

        assertTrue(flowFiles.size() == 1);
        MockFlowFile successFlowFile = flowFiles.get(0);
        successFlowFile.assertContentEquals("Hello Stream");
        successFlowFile.assertAttributeEquals("jms.JMSDestination", "queue.testing");

        producer.close();
        jmsSession.close();
    }

    @org.junit.Ignore
    public void testSendMapToQueue() throws Exception {
        final TestRunner runner = TestRunners.newTestRunner(GetJMSQueue.class);
        runner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        runner.setProperty(JmsProperties.URL, "tcp://localhost:61616");
        runner.setProperty(JmsProperties.DESTINATION_TYPE, JmsProperties.DESTINATION_TYPE_QUEUE);
        runner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        runner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);
        WrappedMessageProducer wrappedProducer = JmsFactory.createMessageProducer(runner.getProcessContext(), true);
        final Session jmsSession = wrappedProducer.getSession();
        final MessageProducer producer = wrappedProducer.getProducer();

        final MapMessage message = jmsSession.createMapMessage();
        message.setString("foo!", "bar");
        message.setString("bacon", "meat");

        producer.send(message);
        jmsSession.commit();
        producer.close();
        jmsSession.close();
    }

    @org.junit.Ignore
    public void testSendObjectToQueue() throws Exception {
        final TestRunner runner = TestRunners.newTestRunner(GetJMSQueue.class);
        runner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
        runner.setProperty(JmsProperties.URL, "tcp://localhost:61616");
        runner.setProperty(JmsProperties.DESTINATION_TYPE, JmsProperties.DESTINATION_TYPE_QUEUE);
        runner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
        runner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);
        WrappedMessageProducer wrappedProducer = JmsFactory.createMessageProducer(runner.getProcessContext(), true);
        final Session jmsSession = wrappedProducer.getSession();
        final MessageProducer producer = wrappedProducer.getProducer();

        // Revision class is used because test just needs any Serializable class in core NiFi
        final ObjectMessage message = jmsSession.createObjectMessage(new Revision(1L, "ID", "COMP_ID"));

        producer.send(message);
        jmsSession.commit();
        producer.close();
        jmsSession.close();
    }
}


text:
namespace Dropbox.Api.Files
{
    using sys = System;
    using col = System.Collections.Generic;
    using re = System.Text.RegularExpressions;

    using enc = Dropbox.Api.Stone;

    /// <summary>
    /// <para>The list folder longpoll arg object</para>
    /// </summary>
    public class ListFolderLongpollArg
    {
        #pragma warning disable 108

        /// <summary>
        /// <para>The encoder instance.</para>
        /// </summary>
        internal static enc.StructEncoder<ListFolderLongpollArg> Encoder = new ListFolderLongpollArgEncoder();

        /// <summary>
        /// <para>The decoder instance.</para>
        /// </summary>
        internal static enc.StructDecoder<ListFolderLongpollArg> Decoder = new ListFolderLongpollArgDecoder();

        /// <summary>
        /// <para>Initializes a new instance of the <see cref="ListFolderLongpollArg" />
        /// class.</para>
        /// </summary>
        /// <param name="cursor">A cursor as returned by <see
        /// cref="Dropbox.Api.Files.Routes.FilesRoutes.ListFolderAsync" /> or <see
        /// cref="Dropbox.Api.Files.Routes.FilesRoutes.ListFolderContinueAsync" />. Cursors
        /// retrieved by setting <see cref="Dropbox.Api.Files.ListFolderArg.IncludeMediaInfo"
        /// /> to <c>true</c> are not supported.</param>
        /// <param name="timeout">A timeout in seconds. The request will block for at most this
        /// length of time, plus up to 90 seconds of random jitter added to avoid the
        /// thundering herd problem. Care should be taken when using this parameter, as some
        /// network infrastructure does not support long timeouts.</param>
        public ListFolderLongpollArg(string cursor,
                                     ulong timeout = 30)
        {
            if (cursor == null)
            {
                throw new sys.ArgumentNullException("cursor");
            }
            if (cursor.Length < 1)
            {
                throw new sys.ArgumentOutOfRangeException("cursor", "Length should be at least 1");
            }

            if (timeout < 30UL)
            {
                throw new sys.ArgumentOutOfRangeException("timeout", "Value should be greater or equal than 30");
            }
            if (timeout > 480UL)
            {
                throw new sys.ArgumentOutOfRangeException("timeout", "Value should be less of equal than 480");
            }

            this.Cursor = cursor;
            this.Timeout = timeout;
        }

        /// <summary>
        /// <para>Initializes a new instance of the <see cref="ListFolderLongpollArg" />
        /// class.</para>
        /// </summary>
        /// <remarks>This is to construct an instance of the object when
        /// deserializing.</remarks>
        public ListFolderLongpollArg()
        {
            this.Timeout = 30;
        }

        /// <summary>
        /// <para>A cursor as returned by <see
        /// cref="Dropbox.Api.Files.Routes.FilesRoutes.ListFolderAsync" /> or <see
        /// cref="Dropbox.Api.Files.Routes.FilesRoutes.ListFolderContinueAsync" />. Cursors
        /// retrieved by setting <see cref="Dropbox.Api.Files.ListFolderArg.IncludeMediaInfo"
        /// /> to <c>true</c> are not supported.</para>
        /// </summary>
        public string Cursor { get; protected set; }

        /// <summary>
        /// <para>A timeout in seconds. The request will block for at most this length of time,
        /// plus up to 90 seconds of random jitter added to avoid the thundering herd problem.
        /// Care should be taken when using this parameter, as some network infrastructure does
        /// not support long timeouts.</para>
        /// </summary>
        public ulong Timeout { get; protected set; }

        #region Encoder class

        /// <summary>
        /// <para>Encoder for  <see cref="ListFolderLongpollArg" />.</para>
        /// </summary>
        private class ListFolderLongpollArgEncoder : enc.StructEncoder<ListFolderLongpollArg>
        {
            /// <summary>
            /// <para>Encode fields of given value.</para>
            /// </summary>
            /// <param name="value">The value.</param>
            /// <param name="writer">The writer.</param>
            public override void EncodeFields(ListFolderLongpollArg value, enc.IJsonWriter writer)
            {
                WriteProperty("cursor", value.Cursor, writer, enc.StringEncoder.Instance);
                WriteProperty("timeout", value.Timeout, writer, enc.UInt64Encoder.Instance);
            }
        }

        #endregion

        #region Decoder class

        /// <summary>
        /// <para>Decoder for  <see cref="ListFolderLongpollArg" />.</para>
        /// </summary>
        private class ListFolderLongpollArgDecoder : enc.StructDecoder<ListFolderLongpollArg>
        {
            /// <summary>
            /// <para>Create a new instance of type <see cref="ListFolderLongpollArg"
            /// />.</para>
            /// </summary>
            /// <returns>The struct instance.</returns>
            protected override ListFolderLongpollArg Create()
            {
                return new ListFolderLongpollArg();
            }

            /// <summary>
            /// <para>Set given field.</para>
            /// </summary>
            /// <param name="value">The field value.</param>
            /// <param name="fieldName">The field name.</param>
            /// <param name="reader">The json reader.</param>
            protected override void SetField(ListFolderLongpollArg value, string fieldName, enc.IJsonReader reader)
            {
                switch (fieldName)
                {
                    case "cursor":
                        value.Cursor = enc.StringDecoder.Instance.Decode(reader);
                        break;
                    case "timeout":
                        value.Timeout = enc.UInt64Decoder.Instance.Decode(reader);
                        break;
                    default:
                        reader.Skip();
                        break;
                }
            }
        }

        #endregion
    }
}

redpajama_set_name: RedPajamaGithub


text:
Subdomain-scanner based on python (beautiful-soup) and virustotal.com

Usage:

python sub.py nsa.gov

Result:

emsm-gh1-uea11.nsa.gov
emsm-gh1-uea10.nsa.gov
remoteoffice1.nsa.gov
careers.nsa.gov
dsdn-gh1-uea05.nsa.gov
m.nsa.gov
remoteoffice.nsa.gov


text:
#include <aws/apigateway/model/CreateDomainNameRequest.h>
#include <aws/core/utils/json/JsonSerializer.h>

#include <utility>

using namespace Aws::APIGateway::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;

CreateDomainNameRequest::CreateDomainNameRequest() :
    m_domainNameHasBeenSet(false),
    m_certificateNameHasBeenSet(false),
    m_certificateBodyHasBeenSet(false),
    m_certificatePrivateKeyHasBeenSet(false),
    m_certificateChainHasBeenSet(false),
    m_certificateArnHasBeenSet(false),
    m_regionalCertificateNameHasBeenSet(false),
    m_regionalCertificateArnHasBeenSet(false),
    m_endpointConfigurationHasBeenSet(false)
{
}

Aws::String CreateDomainNameRequest::SerializePayload() const
{
  JsonValue payload;

  if(m_domainNameHasBeenSet)
  {
   payload.WithString("domainName", m_domainName);

  }

  if(m_certificateNameHasBeenSet)
  {
   payload.WithString("certificateName", m_certificateName);

  }

  if(m_certificateBodyHasBeenSet)
  {
   payload.WithString("certificateBody", m_certificateBody);

  }

  if(m_certificatePrivateKeyHasBeenSet)
  {
   payload.WithString("certificatePrivateKey", m_certificatePrivateKey);

  }

  if(m_certificateChainHasBeenSet)
  {
   payload.WithString("certificateChain", m_certificateChain);

  }

  if(m_certificateArnHasBeenSet)
  {
   payload.WithString("certificateArn", m_certificateArn);

  }

  if(m_regionalCertificateNameHasBeenSet)
  {
   payload.WithString("regionalCertificateName", m_regionalCertificateName);

  }

  if(m_regionalCertificateArnHasBeenSet)
  {
   payload.WithString("regionalCertificateArn", m_regionalCertificateArn);

  }

  if(m_endpointConfigurationHasBeenSet)
  {
   payload.WithObject("endpointConfiguration", m_endpointConfiguration.Jsonize());

  }

  return payload.View().WriteReadable();
}


text:
const path = require('path');
var webpack = require('webpack');
var CompressionPlugin = require('compression-webpack-plugin');
var Visualizer = require('webpack-visualizer-plugin');

module.exports = {
  entry: {
    // "app.min": [__dirname + '/src'],
    // "boxencrypt-standalone.min": [__dirname + '/src/components/wrapper/standalone-box-encrypt.js'],
    // "boxdecrypt-standalone.min": [__dirname + '/src/components/wrapper/standalone-box-decrypt.js'],
    "modalencrypt-standalone.min": ['babel-polyfill', 'whatwg-fetch', __dirname + '/src/components/wrapper/standalone-modal-encrypt.js'],
    "modaldecrypt-standalone.min": ['babel-polyfill', 'whatwg-fetch', __dirname + '/src/components/wrapper/standalone-modal-decrypt.js'],
  },
  output: {
    path: path.resolve(__dirname, 'bundles'),
    filename: '[name].js',
    publicPath: '/bundles/',
    library: 'sindejs',
    libraryTarget: 'umd'
  },
  devtool: "cheap-module-source-map",
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /(node_modules|bower_components)/,
        use: {
          loader: 'babel-loader',
        }
      },
      {
        test: /\.jsx$/,
        exclude: /(node_modules|bower_components)/,
        use: {
          loader: 'babel-loader',
        }
      },
      { test: /\.styl$/, loader: 'style-loader!css-loader!stylus-loader' }
      ,{
            test: /\.less$/,
            use: [{
                loader: "style-loader" // creates style nodes from JS strings
            }, {
                loader: "css-loader" // translates CSS into CommonJS
            }, {
                loader: "less-loader" // compiles Less to CSS
            }]
        }
      ,{
        test: /\.css$/,
        use: [ 'style-loader', 'css-loader' ]
      }
    ]
  },
  plugins: [
    new webpack.LoaderOptionsPlugin({
      minimize: true,
      debug: false
    }),
    // new webpack.DefinePlugin({
    //   'process.env':{
    //     'NODE_ENV': JSON.stringify('production')
    //   }
    // }),
    new webpack.DefinePlugin({
      'process.env.NODE_ENV': '"production"'
    }),

    new webpack.optimize.UglifyJsPlugin({
      beatify:false,
      comments: false,
      mangle: {
        screw_ie8: true,
        keep_fnames: true
      },
      compress:{
        screw_ie8: true,
        warnings: false,
        drop_console: true
      }
    }),

    // new webpack.optimize.UglifyJsPlugin({
    //   mangle: true,
    //   compress: {
    //     warnings: false, // Suppress uglification warnings
    //     pure_getters: true,
    //     unsafe: true,
    //     unsafe_comps: true,
    //     screw_ie8: true
    //   },
    //   output: {
    //     comments: false,
    //   },
    //   exclude: [/\.min\.js$/gi] // skip pre-minified libs
    // }),

    // new webpack.IgnorePlugin(/^\.\/locale$/, [/moment$/]),

    new webpack.NoEmitOnErrorsPlugin(),

    new webpack.optimize.AggressiveMergingPlugin(),

    new Visualizer(),
  ],
  resolve: {
    alias: {
      'react': path.join(__dirname, 'node_modules', 'react')
    },
    extensions: ['.js', '.jsx', '.styl']
  },
  externals: {
    'react': 'React',
    'react-dom': 'ReactDOM',
    'jsrsasign': 'jsrsasign',
  }
};


text:
=========================
LLVM 11.0.0 Release Notes
=========================

.. contents::
    :local:

.. warning::
   These are in-progress notes for the upcoming LLVM 11 release.
   Release notes for previous releases can be found on
   `the Download Page <https://releases.llvm.org/download.html>`_.

Introduction
============

This document contains the release notes for the LLVM Compiler Infrastructure,
release 11.0.0.  Here we describe the status of LLVM, including major improvements
from the previous release, improvements in various subprojects of LLVM, and
some of the current users of the code.  All LLVM releases may be downloaded
from the `LLVM releases web site <https://llvm.org/releases/>`_.

For more information about LLVM, including information about the latest
release, please check out the `main LLVM web site <https://llvm.org/>`_.  If you
have questions or comments, the `LLVM Developer's Mailing List
<https://lists.llvm.org/mailman/listinfo/llvm-dev>`_ is a good place to send
them.

Note that if you are reading this file from a Git checkout or the main
LLVM web page, this document applies to the *next* release, not the current
one.  To see the release notes for a specific release, please see the `releases
page <https://llvm.org/releases/>`_.

Non-comprehensive list of changes in this release
=================================================
.. NOTE
   For small 1-3 sentence descriptions, just add an entry at the end of
   this list. If your description won't fit comfortably in one bullet
   point (e.g. maybe you would like to give an example of the
   functionality, or simply have a lot to talk about), see the `NOTE` below
   for adding a new subsection.

* ...

.. NOTE
   If you would like to document a larger change, then you can add a
   subsection about it right here. You can copy the following boilerplate
   and un-indent it (the indentation causes it to be inside this comment).

   Special New Feature
   -------------------

   Makes programs 10x faster by doing Special New Thing.

Changes to the LLVM IR
----------------------

* The callsite attribute `vector-function-abi-variant
  <https://llvm.org/docs/LangRef.html#call-site-attributes>`_ has been
  added to describe the mapping between scalar functions and vector
  functions, to enable vectorization of call sites. The information
  provided by the attribute is interfaced via the API provided by the
  ``VFDatabase`` class.

Changes to building LLVM
------------------------

Changes to the ARM Backend
--------------------------

During this release ...

* Implemented C-language intrinsics for the full Arm v8.1-M MVE instruction
  set. ``<arm_mve.h>`` now supports the complete API defined in the Arm C
  Language Extensions.

* Added support for assembly for the optional Custom Datapath Extension (CDE)
  for Arm M-profile targets.

* Implemented C-language intrinsics ``<arm_cde.h>`` for the CDE instruction set.

Changes to the MIPS Target
--------------------------

During this release ...

Changes to the PowerPC Target
-----------------------------

During this release ...

Changes to the X86 Target
-------------------------

During this release ...

* Functions with the probe-stack attribute set to "inline-asm" are now protected
  against stack clash without the need of a third-party probing function and
  with limited impact on performance.
* -x86-enable-old-knl-abi command line switch has been removed. v32i16/v64i8
  vectors are always passed in ZMM register when avx512f is enabled and avx512bw
  is disabled.
* Vectors larger than 512 bits with i16 or i8 elements will be passed in
  multiple ZMM registers when avx512f is enabled. Previously this required
  avx512bw otherwise they would split into multiple YMM registers. This means
  vXi16/vXi8 vectors are consistently treated the same as
  vXi32/vXi64/vXf64/vXf32 vectors of the same total width.

Changes to the AMDGPU Target
-----------------------------

* The backend default denormal handling mode has been switched to on
  for all targets for all compute function types. Frontends wishing to
  retain the old behavior should explicitly request f32 denormal
  flushing.

Changes to the AVR Target
-----------------------------

* Moved from an experimental backend to an official backend. AVR support is now
  included by default in all LLVM builds and releases and is available under
  the "avr-unknown-unknown" target triple.

Changes to the WebAssembly Target
---------------------------------

During this release ...

Changes to the OCaml bindings
-----------------------------

Changes to the C API
--------------------

Changes to the Go bindings
--------------------------

Changes to the DAG infrastructure
---------------------------------

Changes to the Debug Info
---------------------------------

* LLVM now supports the debug entry values (DW_OP_entry_value) production for
  the x86, ARM, and AArch64 targets by default. Other targets can use
  the utility by using the experimental option ("-debug-entry-values").
  This is a debug info feature that allows debuggers to recover the value of
  optimized-out parameters by going up a stack frame and interpreting the values
  passed to the callee. The feature improves the debugging user experience when
  debugging optimized code.

Changes to the LLVM tools
---------------------------------

* Added an option (--show-section-sizes) to llvm-dwarfdump to show the sizes
  of all debug sections within a file.

Changes to LLDB
===============

External Open Source Projects Using LLVM 11
===========================================

* A project...

Additional Information
======================

A wide variety of additional information is available on the `LLVM web page
<https://llvm.org/>`_, in particular in the `documentation
<https://llvm.org/docs/>`_ section.  The web page also contains versions of the
API documentation which is up-to-date with the Git version of the source
code.  You can access versions of these documents specific to this release by
going into the ``llvm/docs/`` directory in the LLVM tree.

If you have any questions or comments about LLVM, please feel free to contact
us via the `mailing lists <https://llvm.org/docs/#mailing-lists>`_.


text:
import { CommonModule } from '@angular/common';
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';

import { LoginRoutingModule } from './login-routing.module';
import { LoginComponent } from './login.component';

import { APP_CONFIG, AppConfig } from "../shared/configs/app.config";

import { AuthService } from "../shared/core/auth.service";

@NgModule({
    imports: [
        CommonModule,
        LoginRoutingModule,
        FormsModule
    ],
    declarations: [LoginComponent],
    providers: [
        AuthService,
        { provide: APP_CONFIG, useValue: AppConfig }
    ]
})
export class LoginModule {
}


text:
NLS_LANG=AMERICAN_AMERICA.US7ASCII
export NLS_LANG;

cd logger
sqlplus /nolog <<EOF
@drop.sql
EOF
cd ..

cd sys
sqlplus /nolog <<EOF
@drop.sql
EOF
cd ..


text:
// ********************************************************************************************************
// Product Name: DotSpatial.Data.dll
// Description:  The data access libraries for the DotSpatial project.
// ********************************************************************************************************
//
// The Initial Developer of this Original Code is Ted Dunsford. Created 11/5/2010 6:59:48 PM
//
// Contributor(s): (Open source contributors should list themselves and their modifications here).
// |      Name            |    Date     |                                Comments
// |----------------------|-------------|-----------------------------------------------------------------
// ********************************************************************************************************

using System;
using System.Data;
using GeoAPI.Geometries;
using NetTopologySuite.IO;

namespace DotSpatial.Data
{
    /// <summary>
    ///Represents strongly named DataRow class.
    ///</summary>
    public class FeatureRow : DataRow, IFeatureRow
    {
        #region Private Variables

        private readonly FeatureTable _featureTable;
        private IExtent _extent;
        private IGeometry _geometry;
        private Shape _shape;

        #endregion

        #region Constructors

        /// <summary>
        /// Creates a new instance of the FeatureRow class.
        /// </summary>
        /// <param name="rb"></param>
        internal FeatureRow(DataRowBuilder rb)
            : base(rb)
        {
            _featureTable = ((FeatureTable)(Table));
        }

        #endregion

        #region Methods

        /// <summary>
        /// Stores the shape into the WKB for storage in a database, overwriting any existing value.
        /// </summary>
        public void StoreShape()
        {
            this[_featureTable.GeometryColumn] = _shape.ToGeometry(_featureTable.GeometryFactory).AsBinary();
        }

        /// <summary>
        /// Stores the geometry as WKB, overwriting any existing value.
        /// </summary>
        public void StoreGeometry()
        {
            this[_featureTable.GeometryColumn] = _geometry.AsBinary();
        }

        /// <summary>
        /// Sets the geometry field to DBNull.
        /// </summary>
        public void SetWellKnwonBinaryNull()
        {
            this[_featureTable.GeometryColumn] = Convert.DBNull;
        }

        #endregion

        #region Properties

        /// <summary>
        /// A long integer representing the FID.
        /// </summary>
        public long FID
        {
            get
            {
                return ((long)(this[_featureTable.FidColumn]));
            }
            set
            {
                this[_featureTable.FidColumn] = value;
            }
        }

        /// <summary>
        /// The Byte form of the Geometry
        /// </summary>
        public byte[] WellKnownBinary
        {
            get
            {
                try
                {
                    return ((byte[])(this[_featureTable.GeometryColumn]));
                }
                catch (InvalidCastException e)
                {
                    throw new StrongTypingException("The value for column \'GEOMETRY\' in table \'FeatureTable\' is DBNull.", e);
                }
            }
            set
            {
                this[_featureTable.GeometryColumn] = value;
            }
        }

        /// <summary>
        /// From shapefiles, this should be cached.  Any other source must likely
        /// create the extent from a geometry, and possibly all the way from WKB.
        /// </summary>
        public IExtent Extent
        {
            get
            {
                if (_extent == null)
                {
                    if (_geometry == null)
                    {
                        if (IsWellKnownBinaryNull())
                        {
                            if (_shape == null)
                            {
                                return null;
                            }
                        }
                    }
                    // Accessing property here to try to create geometry.
                    IGeometry lazyGeom = Geometry;
                    if (lazyGeom == null) return null;
                    _extent = lazyGeom.EnvelopeInternal.ToExtent();
                }
                return _extent;
            }
            set
            {
                _extent = value;
            }
        }

        /// <summary>
        /// A lazily created and cached geometry.
        /// </summary>
        public IGeometry Geometry
        {
            get
            {
                if (_geometry == null)
                {
                    if (IsWellKnownBinaryNull())
                    {
                        return _shape == null ? null : _shape.ToGeometry(_featureTable.GeometryFactory);
                    }
                    WKBReader reader = new WKBReader(_featureTable.GeometryFactory);
                    byte[] geometryBytes = (byte[])this[_featureTable.GeometryColumn];

                    _geometry = reader.Read(geometryBytes);
                    return _geometry;
                }
                return _geometry;
            }
            set { _geometry = value; }
        }

        /// <summary>
        /// Boolean, true if the extent has been created, false otherwise.
        /// </summary>
        public bool IsExtentCreated
        {
            get { return _extent != null; }
        }

        /// <summary>
        /// Boolean, true if the geometry has already been created, false otherwise.
        /// </summary>
        public bool IsGeometryCreated
        {
            get { return (_geometry != null); }
        }

        /// <summary>
        /// Boolean, true if the shape has already been created, false otherwise.
        /// </summary>
        public bool IsShapeCreated
        {
            get { return (_shape != null); }
        }

        /// <summary>
        /// When reading from WKB, the Shape is lazily created.  When reading from sources like
        /// a shapefile, the Shape is actually pre-fetched because the value exists as a shape
        /// rather than a geometry.
        /// </summary>
        public Shape Shape
        {
            get { return _shape ?? (_shape = new Shape(Geometry, FeatureType.Unspecified)); }
            set { _shape = value; }
        }

        /// <summary>
        /// Gets whether the geometry is null.
        /// </summary>
        /// <returns>Boolean, true if the column is null.</returns>
        public bool IsWellKnownBinaryNull()
        {
            return IsNull(_featureTable.GeometryColumn);
        }

        #endregion
    }
}


text:
{SystemName}: {Login}

{ErrorMessage}

<form action="login.html" id="login_form" method="POST">

{UserNameText}*

      <input require="true" label="username" id="login_input" name="username" type="text"/>

{PasswordText}*

      <input require="true" label="password" id="login_input" type="password" name="password" />

{ForgotPassword}

      <button id="login_bouton" type="Submit" name="Submit" value="Submit">{Submit}</button>

</form>


text:
`country_select` 2.0 has brought a few small changes, but these changes
can have a big impact on existing production systems. Please read these
points carefully and consider whether upgrading to 2.0 is a good idea.

Please post any implications we may have missed as a GitHub Issue
or Pull Request.

## ISO codes are always on

If you upgrade to 2.0 and are currently storing countries by the names
produced by this gem, your setup will break. It is recommended that you
stick with 1.x until developing a data migration strategy that allows
you to map your existing country names to country codes.

## i18n country names are always on (when available)

Country names will be generated using `I18n.locale` if a translation
from the countries gem is available.

## Codes are UPCASED

The official ISO 3166-1 standard uses UPCASED codes. This is an easy
data change, but may affect areas of code dependent on lowercase country
codes.

Here's a sample SQL migration that could address a `users` table with
lowercased country codes stored in the `country_code` column:

```sql
UPDATE users SET country_code = UPPER(country_code);
```

## Priority countries are now in the options hash

The priority countries syntax has changed from

```ruby
  country_select(:user, :country_code, ["GB","FR"])
```

to

```ruby
  country_select(:user, :country_code, priority_countries: ["GB","FR"])
```

### A note on 1.x Syntax

In order to seamlessly support popular libraries dependent on
`country_select`, specifically `formatstic` and `simple_form`, 1.x
priority syntax is still supported, but will probably be removed in the
next major release (i.e., 3.0). We'll be working with `simple_form` and
`formtastic` maintainers to transition away from the old 1.x syntax.

## You can choose to only display a chosen set of countries

```ruby
  country_select(:user, :country_code, only: ["LV","SG"])
```

```ruby
  country_select(:user, :country_code, except: ["US","GB"])
```

## Ruby 1.9+

`country_select` will no longer be tested in Ruby `< 1.9`.


text:
class C_BaseAnimating;

//--------------------------------------------------------------------------------

struct RagdollSimulationFrame_t
{
	RagdollSimulationFrame_t() : pPositions(NULL), pAngles(NULL), nTick(-1) {}

	static RagdollSimulationFrame_t* Alloc( int nNumBones );

	int			nTick;
	Vector*		pPositions;
	QAngle*		pAngles;
	Vector		vRootPosition;
	QAngle		angRootAngles;
};

//--------------------------------------------------------------------------------

struct RagdollSimulationData_t
{
	RagdollSimulationData_t( C_BaseAnimating* pEntity = NULL, int nStartTick = 0, int nNumBones = 0 );

	void Record();

	int	m_nEntityIndex;
	int	m_nStartTick;
	int	m_nDuration;
	int m_nNumBones;

	typedef unsigned short Iterator_t;

	CUtlLinkedList< RagdollSimulationFrame_t*, Iterator_t > m_lstFrames;
	C_BaseAnimating* m_pEntity;
};

//--------------------------------------------------------------------------------

// TODO: Refactor this into an interface and hide implementation in cpp file

class CReplayRagdollRecorder
{
private:
	CReplayRagdollRecorder();
	~CReplayRagdollRecorder();

public:
	static CReplayRagdollRecorder& Instance();

	void Init();
	void Shutdown();

	void Think();

	void AddEntry( C_BaseAnimating* pEntity, int nStartTick, int nNumBones );
	void StopRecordingRagdoll( C_BaseAnimating* pEntity );

	void CleanupStartupTicksAndDurations( int nStartTick );
	bool DumpRagdollsToDisk( char const* pszFilename ) const;

	bool IsRecording() const		{ return m_bIsRecording; }

private:
	typedef unsigned short Iterator_t;

	void StopRecordingRagdollAtIndex( Iterator_t nIndex );

	void StopRecordingSleepingRagdolls();
	void Record();

	bool FindEntryInRecordingList( C_BaseAnimating* pEntity, Iterator_t& nOutIndex );

	void PrintDebug();

	CUtlLinkedList< RagdollSimulationData_t*, Iterator_t > m_lstRagdolls;
	CUtlLinkedList< RagdollSimulationData_t*, Iterator_t > m_lstRagdollsToRecord;	// Contains some of the elements from m_lstRagdolls -
																					// the ones which are still recording
	bool m_bIsRecording;
};

//--------------------------------------------------------------------------------

class CReplayRagdollCache
{
private:
	CReplayRagdollCache();

public:
	static CReplayRagdollCache& Instance();

	bool Init( char const* pszFilename );
	void Shutdown();

	void Think();

	bool IsInitialized() const				{ return m_bInit; }

	//
	// Returns false is no frame exists for the given entity at the given tick.
	// Otherwise, returns a
	//
	bool GetFrame( C_BaseAnimating* pEntity, int nTick, bool* pBoneSimulated, CBoneAccessor* pBoneAccessor ) const;

private:
	RagdollSimulationData_t* FindRagdollEntry( C_BaseAnimating* pEntity, int nTick );
	const RagdollSimulationData_t* FindRagdollEntry( C_BaseAnimating* pEntity, int nTick ) const;

	bool FindFrame( RagdollSimulationFrame_t*& pFrameOut, RagdollSimulationFrame_t*& pNextFrameOut,
		const RagdollSimulationData_t* pRagdollEntry, int nTick );
	bool FindFrame( RagdollSimulationFrame_t*& pFrameOut, RagdollSimulationFrame_t*& pNextFrameOut,
		const RagdollSimulationData_t* pRagdollEntry, int nTick ) const;

	typedef unsigned short Iterator_t;
	bool m_bInit;

	CUtlLinkedList< RagdollSimulationData_t*, Iterator_t > m_lstRagdolls;
};

//--------------------------------------------------------------------------------

bool Replay_CacheRagdolls( const char* pFilename, int nStartTick );

//--------------------------------------------------------------------------------

inline const RagdollSimulationData_t* CReplayRagdollCache::FindRagdollEntry( C_BaseAnimating* pEntity, int nTick ) const
{
	return const_cast< CReplayRagdollCache* >( this )->FindRagdollEntry( pEntity, nTick );
}

inline bool CReplayRagdollCache::FindFrame( RagdollSimulationFrame_t*& pFrameOut, RagdollSimulationFrame_t*& pNextFrameOut,
											const RagdollSimulationData_t* pRagdollEntry, int nTick ) const
{
	return const_cast< CReplayRagdollCache* >( this )->FindFrame( pFrameOut, pNextFrameOut, pRagdollEntry, nTick );
}

//--------------------------------------------------------------------------------

#endif // REPLAY_RAGDOLL_H


text:
use ansi_term::Style;

use crate::fs::fields as f;
use crate::output::cell::TextCell;

impl f::Inode {
    pub fn render(self, style: Style) -> TextCell {
        TextCell::paint(style, self.0.to_string())
    }
}

#[cfg(test)]
pub mod test {
    use crate::output::cell::TextCell;
    use crate::fs::fields as f;

    use ansi_term::Colour::*;

    #[test]
    fn blocklessness() {
        let io = f::Inode(1414213);
        let expected = TextCell::paint_str(Cyan.underline(), "1414213");
        assert_eq!(expected, io.render(Cyan.underline()).into());
    }
}