text:
YUI.add('aui-datatable-radio-cell-editor', function (A, NAME) {

/**
 * RadioCellEditor class.
 *
 * @class A.RadioCellEditor
 * @extends A.CheckboxCellEditor
 * @param {Object} config Object literal specifying widget configuration
 * properties.
 * @constructor
 */
var RadioCellEditor = A.Component.create({

    /**
     * Static property provides a string to identify the class.
     *
     * @property NAME
     * @type String
     * @static
     */
    NAME: 'radioCellEditor',

    /**
     * Static property used to define which component it extends.
     *
     * @property EXTENDS
     * @type Object
     * @static
     */
    EXTENDS: A.CheckboxCellEditor,

    prototype: {
        OPTION_TEMPLATE: '<input class="field-input-choice" id="{id}" name="{name}" type="radio" value="{value}"/>',
        OPTION_WRAPPER: '<label class="radio" for="{id}"> {label}</label>',

        /**
         * Gets the `A.RadioCellEditor` input value.
         *
         * @method getElementsValue
         * @return {String} Input value.
         */
        getElementsValue: function() {
            var instance = this;

            return instance._getSelectedOptions().get('value')[0];
        }
    }
});

A.RadioCellEditor = RadioCellEditor;

}, '3.0.0', {"requires": ["aui-datatable-base-options-cell-editor"]});


text:
<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginTop="?attr/actionBarSize"
    tools:context="com.jetlag.jcreator.activity.chatstory.ChatStoryActivity"
    tools:showIn="@layout/activity_chat_story">

    <include
        android:id="@+id/input_options"
        layout="@layout/input_options" />

    <include
        android:id="@+id/next_paragraph"
        layout="@layout/input_paragraph" />

    <android.support.v7.widget.RecyclerView
        android:id="@+id/paragraphs"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_above="@id/next_paragraph"
        android:layout_alignParentTop="true" />

</RelativeLayout>

redpajama_set_name: RedPajamaGithub


text:
#ifndef QDECLARATIVEJSNODEPOOL_P_H
#define QDECLARATIVEJSNODEPOOL_P_H

//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//

#include "qdeclarativejsglobal_p.h"
#include "qdeclarativejsmemorypool_p.h"

#include <QtCore/QHash>
#include <QtCore/QString>

QT_QML_BEGIN_NAMESPACE

namespace QDeclarativeJS {

namespace AST {
class Node;
} // namespace AST

class Code;
class CompilationUnit;
class Engine;

template <typename NodeType>
inline NodeType *makeAstNode(MemoryPool *storage)
{
    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType();
    return node;
}

template <typename NodeType, typename Arg1>
inline NodeType *makeAstNode(MemoryPool *storage, Arg1 arg1)
{
    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType(arg1);
    return node;
}

template <typename NodeType, typename Arg1, typename Arg2>
inline NodeType *makeAstNode(MemoryPool *storage, Arg1 arg1, Arg2 arg2)
{
    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType(arg1, arg2);
    return node;
}

template <typename NodeType, typename Arg1, typename Arg2, typename Arg3>
inline NodeType *makeAstNode(MemoryPool *storage, Arg1 arg1, Arg2 arg2, Arg3 arg3)
{
    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType(arg1, arg2, arg3);
    return node;
}

template <typename NodeType, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
inline NodeType *makeAstNode(MemoryPool *storage, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
{
    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType(arg1, arg2, arg3, arg4);
    return node;
}

class QML_PARSER_EXPORT NodePool : public MemoryPool
{
public:
    NodePool(const QString &fileName, Engine *engine);
    virtual ~NodePool();

    Code *createCompiledCode(AST::Node *node, CompilationUnit &compilation);

    inline QString fileName() const { return m_fileName; }
    inline Engine *engine() const { return m_engine; }
#ifndef J_SCRIPT_NO_EVENT_NOTIFY
    inline qint64 id() const { return m_id; }
#endif

private:
    QHash<AST::Node*, Code*> m_codeCache;
    QString m_fileName;
    Engine *m_engine;
#ifndef J_SCRIPT_NO_EVENT_NOTIFY
    qint64 m_id;
#endif

private:
    Q_DISABLE_COPY(NodePool)
};

} // namespace QDeclarativeJS

QT_QML_END_NAMESPACE

#endif


text:
    #set $idata = $interfaces[$iname]
    #set $static        = $idata["static"]
    #set $management    = $idata["management"]
    #set $ip            = $idata["ip_address"]
    #if $management and $ip
        #set $ip_address = $ip
    #end if
#end for

#set $proxy_url = ""
#set $local_repo_url = ""
#if $getVar("local_repo","") != ""
    #set $local_repo_url = $local_repo
#end if
#if $getVar("proxy","") != ""
    #set $proxy_url = $proxy
#end if

#if $getVar('compass_server', '') != ""
    #set srv = $getVar('compass_server','')
#else
    #set srv = $getVar('server','')
#end if

cat << EOF > /etc/chef/chef_client_run.sh
#!/bin/bash
touch /var/log/chef.log
PIDFILE=/tmp/chef_client_run.pid
if [ -f \\$PIDFILE ]; then
    pid=\\$(cat \\$PIDFILE)
    if [ -f /proc/\\$pid/exe ]; then
	echo "there are chef_client_run.sh running with pid \\$pid" >> /var/log/chef.log 2>&1
	exit 1
    fi
fi
echo \\$$ > \\$PIDFILE
while true; do
    echo "run chef-client on \`date\`" >> /var/log/chef.log 2>&1
    clients=\\$(pgrep chef-client)
    if [[ "\\$?" == "0" ]]; then
        echo "there are chef-clients '\\$clients' running" >> /var/log/chef.log 2>&1
        break
    else
        echo "knife search nodes" >> /var/log/chef.log 2>&1
# use knife node list here to check if node has been registered because knife search node
# doesn't work as expected.
        USER=root HOME=/root knife node list |grep \\$HOSTNAME. >> /var/log/chef.log 2>&1
        nodes=\\$(USER=root HOME=/root knife node list |grep \\$HOSTNAME.)
        echo "found nodes \\$nodes" >> /var/log/chef.log 2>&1
        let all_nodes_success=1
        for node in \\$nodes; do
            mkdir -p /var/log/chef/\\$node
	    if [ ! -f /etc/chef/\\$node.json ]; then
                cat << EOL > /etc/chef/\\$node.json
{
    "local_repo": "$local_repo_url",
    "proxy_url": "$proxy_url",
    "ip_address": "$ip_address"
}
EOL
            fi
            if [ ! -f "/etc/chef/\\$node.pem" ]; then
                cat << EOL > /etc/rsyslog.d/\\$node.conf
\\\\$ModLoad imfile
\\\\$InputFileName /var/log/chef/\\$node/chef-client.log
\\\\$InputFileReadMode 0
\\\\$InputFileTag \\$node
\\\\$InputFileStateFile chef_\\${node}_log
\\\\$InputFileSeverity notice
\\\\$InputFileFacility local3
\\\\$InputRunFileMonitor
\\\\$InputFilePollInterval 1
#if $getVar("compass_server","") != ""
local3.info @$compass_server:514
#else
local3.info @@$server:514
#end if
EOL
                rm -rf /var/lib/rsyslog/chef_\\$node_log
                service rsyslog restart
            fi
            if [ -f "/etc/chef/\\$node.done" ]; then
                USER=root HOME=/root chef-client --node-name \\$node -j /etc/chef/\\$node.json --client_key /etc/chef/\\$node.pem >> /var/log/chef.log 2>&1
            else
                USER=root HOME=/root chef-client --node-name \\$node -j /etc/chef/\\$node.json --client_key /etc/chef/\\$node.pem -L /var/log/chef/\\$node/chef-client.log >> /var/log/chef.log 2>&1
            fi
            if [ "\\$?" != "0" ]; then
                echo "chef-client --node-name \\$node run failed"  >> /var/log/chef.log 2>&1
                let all_nodes_success=0
            else
                echo "chef-client --node-name \\$node run success" >> /var/log/chef.log 2>&1
                touch /etc/chef/\\$node.done
                wget -O /tmp/package_state.\\$node --post-data='{"ready": true}' --header=Content-Type:application/json "http://$srv/api/clusterhosts/\\${node}/state_internal"
            fi
        done
        if [ \\$all_nodes_success -eq 0 ]; then
            sleep 1m
        else
            break
        fi
    fi
done
EOF
chmod +x /etc/chef/chef_client_run.sh


text:
<?php

namespace FOS\ElasticaBundle\Doctrine\ORM;

use FOS\ElasticaBundle\Doctrine\AbstractProvider;

class Provider extends AbstractProvider
{
    /**
     * Counts the objects of a query builder
     *
     * @param queryBuilder
     * @return int
     **/
    protected function countObjects($queryBuilder)
    {
        $qb = clone $queryBuilder;
        $qb->select($qb->expr()->count($queryBuilder->getRootAlias()))
            ->resetDQLPart('orderBy'); // no need to order the query. It does not change the count and make the query less efficient.

        return $qb->getQuery()->getSingleScalarResult();
    }

    /**
     * Fetches a slice of objects
     *
     * @param queryBuilder
     * @param int limit
     * @param int offset
     * @return array of objects
     **/
    protected function fetchSlice($queryBuilder, $limit, $offset)
    {
        $queryBuilder->setFirstResult($offset);
        $queryBuilder->setMaxResults($limit);

        return $queryBuilder->getQuery()->getResult();
    }

    /**
     * Creates the query builder used to fetch the documents to index
     *
     * @return query builder
     **/
    protected function createQueryBuilder()
    {
        return $this->objectManager->getRepository($this->objectClass)->{$this->options['query_builder_method']}('a');
    }
}


text:
use core::prelude::*;

use lib::llvm::{ValueRef, TypeRef};
use lib::llvm::False;
use lib::llvm::llvm;
use middle::trans::common::*;
use middle::trans::type_of;
use middle::ty;
use util::ppaux::ty_to_str;

// ______________________________________________________________________
// compute sizeof / alignof

// Returns the number of bytes clobbered by a Store to this type.
pub fn llsize_of_store(cx: @CrateContext, t: TypeRef) -> uint {
    unsafe {
        return llvm::LLVMStoreSizeOfType(cx.td.lltd, t) as uint;
    }
}

// Returns the number of bytes between successive elements of type T in an
// array of T. This is the "ABI" size. It includes any ABI-mandated padding.
pub fn llsize_of_alloc(cx: @CrateContext, t: TypeRef) -> uint {
    unsafe {
        return llvm::LLVMABISizeOfType(cx.td.lltd, t) as uint;
    }
}

// Returns, as near as we can figure, the "real" size of a type. As in, the
// bits in this number of bytes actually carry data related to the datum
// with the type. Not junk, padding, accidentally-damaged words, or
// whatever. Rounds up to the nearest byte though, so if you have a 1-bit
// value, we return 1 here, not 0. Most of rustc works in bytes. Be warned
// that LLVM *does* distinguish between e.g. a 1-bit value and an 8-bit value
// at the codegen level! In general you should prefer `llbitsize_of_real`
// below.
pub fn llsize_of_real(cx: @CrateContext, t: TypeRef) -> uint {
    unsafe {
        let nbits = llvm::LLVMSizeOfTypeInBits(cx.td.lltd, t) as uint;
        if nbits & 7u != 0u {
            // Not an even number of bytes, spills into "next" byte.
            1u + (nbits >> 3)
        } else {
            nbits >> 3
        }
    }
}

/// Returns the "real" size of the type in bits.
pub fn llbitsize_of_real(cx: @CrateContext, t: TypeRef) -> uint {
    unsafe {
        llvm::LLVMSizeOfTypeInBits(cx.td.lltd, t) as uint
    }
}

/// Returns the size of the type as an LLVM constant integer value.
pub fn llsize_of(cx: @CrateContext, t: TypeRef) -> ValueRef {
    // Once upon a time, this called LLVMSizeOf, which does a
    // getelementptr(1) on a null pointer and casts to an int, in
    // order to obtain the type size as a value without requiring the
    // target data layout.  But we have the target data layout, so
    // there's no need for that contrivance.  The instruction
    // selection DAG generator would flatten that GEP(1) node into a
    // constant of the type's alloc size, so let's save it some work.
    return C_uint(cx, llsize_of_alloc(cx, t));
}

// Returns the "default" size of t (see above), or 1 if the size would
// be zero.  This is important for things like vectors that expect
// space to be consumed.
pub fn nonzero_llsize_of(cx: @CrateContext, t: TypeRef) -> ValueRef {
    if llbitsize_of_real(cx, t) == 0 {
        unsafe { llvm::LLVMConstInt(cx.int_type, 1, False) }
    } else {
        llsize_of(cx, t)
    }
}

// Returns the preferred alignment of the given type for the current target.
// The preffered alignment may be larger than the alignment used when
// packing the type into structs. This will be used for things like
// allocations inside a stack frame, which LLVM has a free hand in.
pub fn llalign_of_pref(cx: @CrateContext, t: TypeRef) -> uint {
    unsafe {
        return llvm::LLVMPreferredAlignmentOfType(cx.td.lltd, t) as uint;
    }
}

// Returns the minimum alignment of a type required by the plattform.
// This is the alignment that will be used for struct fields, arrays,
// and similar ABI-mandated things.
pub fn llalign_of_min(cx: @CrateContext, t: TypeRef) -> uint {
    unsafe {
        return llvm::LLVMABIAlignmentOfType(cx.td.lltd, t) as uint;
    }
}

// Returns the "default" alignment of t, which is calculated by casting
// null to a record containing a single-bit followed by a t value, then
// doing gep(0,1) to get at the trailing (and presumably padded) t cell.
pub fn llalign_of(cx: @CrateContext, t: TypeRef) -> ValueRef {
    unsafe {
        return llvm::LLVMConstIntCast(
            llvm::LLVMAlignOf(t), cx.int_type, False);
    }
}

// Computes the size of the data part of an enum.
pub fn static_size_of_enum(cx: @CrateContext, t: ty::t) -> uint {
    if cx.enum_sizes.contains_key(&t) {
        return *cx.enum_sizes.get(&t);
    }

    debug!("static_size_of_enum %s", ty_to_str(cx.tcx, t));

    match ty::get(t).sty {
        ty::ty_enum(tid, ref substs) => {
            // Compute max(variant sizes).
            let mut max_size = 0;
            let variants = ty::enum_variants(cx.tcx, tid);
            for variants.each |variant| {
                if variant.args.len() == 0 {
                    loop;
                }

                let lltypes = variant.args.map(|&variant_arg| {
                    let substituted = ty::subst(cx.tcx, substs, variant_arg);
                    type_of::sizing_type_of(cx, substituted)
                });

                debug!("static_size_of_enum: variant %s type %s",
                       *cx.tcx.sess.str_of(variant.name),
                       ty_str(cx.tn, T_struct(lltypes)));

                let this_size = llsize_of_real(cx, T_struct(lltypes));
                if max_size < this_size {
                    max_size = this_size;
                }
            }
            cx.enum_sizes.insert(t, max_size);
            return max_size;
        }
        _ => cx.sess.bug(~"static_size_of_enum called on non-enum")
    }
}


text:
/**
 * Returns a plural suffix if the value is not 1. By default, `pluralize`
 * uses "s" as the suffix. If a `String` is provided, `pluralize` will attempt
 * to convert it into a `Number`. If an `Array` is provided instead of a
 * number, the length of the `Array` is used to determine the suffix. An
 * alternative plural suffix can be provided as the second parameter, and if
 * necessary, an alternative singular suffix can be provided as the third.
 *
 * @param {number|string|array} value
 * @param {string} [pluralSuffix='s']
 * @param {string} [singularSuffix='']
 * @return {string}
 * @example
 *
 * var journalize = require('journalize');
 *
 * // typical usage
 * 'vote' + journalize.pluralize(0); // votes
 * 'vote' + journalize.pluralize(1); // vote
 * 'vote' + journalize.pluralize(2); // votes
 *
 * // the plural suffix may be changed
 * 'class' + journalize.pluralize(0, 'es'); // classes
 * 'class' + journalize.pluralize(1, 'es'); // class
 * 'class' + journalize.pluralize(2, 'es'); // classes
 *
 * // some words also need a custom singular suffix
 * 'cand' + journalize.pluralize(0, 'ies', 'y'); // candies
 * 'cand' + journalize.pluralize(1, 'ies', 'y'); // candy
 * 'cand' + journalize.pluralize(2, 'ies', 'y'); // candies
 */
export default function pluralize(
  value,
  pluralSuffix = 's',
  singularSuffix = ''
) {
  // if this is an array, base the return value on the length
  if (Array.isArray(value)) {
    if (value.length !== 1) {
      return pluralSuffix;
    } else {
      return singularSuffix;
    }
  }

  // otherwise we have a string or number - convert it and test if its 1
  if (Number(value) !== 1) {
    return pluralSuffix;
  }

  return singularSuffix;
}


text:
<?php

declare(strict_types=1);

namespace ApiPlatform\Tests\Fixtures\TestBundle\Entity;

use ApiPlatform\Metadata\ApiResource;
use Doctrine\ORM\Mapping as ORM;

#[ApiResource]
#[ORM\Entity]
class DummyPassenger
{
    /**
     * @var int The entity Id
     */
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(type: 'integer')]
    private ?int $id = null;
    #[ORM\Column(type: 'string')]
    public $nickname;

    public function getId()
    {
        return $this->id;
    }
}


text:
:mod:`ustruct` -- Pack and unpack primitive data types
======================================================

.. module:: ustruct
   :synopsis: pack and unpack primitive data types

See `Python struct <https://docs.python.org/3/library/struct.html>`_ for more
information.

Supported size/byte order prefixes: ``@``, ``<``, ``>``, ``!``.

Supported format codes: ``b``, ``B``, ``h``, ``H``, ``i``, ``I``, ``l``,
``L``, ``q``, ``Q``, ``s``, ``P``, ``f``, ``d`` (the latter 2 depending
on the floating-point support).

Functions
---------

.. function:: calcsize(fmt)

   Return the number of bytes needed to store the given `fmt`.

.. function:: pack(fmt, v1, v2, ...)

   Pack the values `v1`, `v2`, ... according to the format string `fmt`.
   The return value is a bytes object encoding the values.

.. function:: pack_into(fmt, buffer, offset, v1, v2, ...)

   Pack the values `v1`, `v2`, ... according to the format string `fmt`
   into a `buffer` starting at `offset`. `offset` may be negative to count
   from the end of `buffer`.

.. function:: unpack(fmt, data)

   Unpack from the `data` according to the format string `fmt`.
   The return value is a tuple of the unpacked values.

.. function:: unpack_from(fmt, data, offset=0)

   Unpack from the `data` starting at `offset` according to the format string
   `fmt`. `offset` may be negative to count from the end of `buffer`. The return
   value is a tuple of the unpacked values.


text:
<?php

namespace Jb\Bundle\PhumborBundle\Tests\DependencyInjection;

use Jb\Bundle\PhumborBundle\DependencyInjection\Configuration;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
use Symfony\Component\Config\Definition\Processor;

/**
 * Test configuration
 *
 * @author Jonathan Bouzekri <jonathan.bouzekri@gmail.com>
 */
class ConfigurationTest extends TestCase
{
    /**
     * Test the default configuration
     */
    public function testDefaultConfig()
    {
        $processor = new Processor();
        $config = $processor->processConfiguration(new Configuration(), array());

        $this->assertEquals(
            self::getBundleDefaultConfig(),
            $config
        );
    }

    /**
     * Test the server configuration
     */
    public function testServerConfiguration()
    {
        $processor = new Processor();
        $config = $processor->processConfiguration(new Configuration(), array(
            array(
                'server' => array(
                    'url' => 'http://jb.phumbor.fr:8888',
                    'secret' => '123456789'
                )
            )
        ));

        $this->assertEquals($config['server']['url'], 'http://jb.phumbor.fr:8888');
        $this->assertEquals($config['server']['secret'], '123456789');
    }

    public function testTransformationMerging()
    {
        // When a transformation is re-defined (overridden) in a later config file,
        // the newer definition entirely replaces the older one.

        $processor = new Processor();
        $config = $processor->processConfiguration(new Configuration(), array(
            // Values from first config file
            array(
                'transformations' => array(
                    'test_not_overridden' => array(
                        'resize' => array('width' => 100, 'height' => 100),
                    ),
                    'test_overridden' => array(
                        'filters' => array(array('name' => 'quality', 'arguments' => array(60))),
                        'resize' => array('width' => 100, 'height' => 100),
                    ),
                )
            ),
            // Values from second config file, should win
            array(
                'transformations' => array(
                    'test_overridden' => array(
                        'resize' => array('width' => 200, 'height' => 200),
                    ),
                )
            ),
        ));

        $this->assertEquals(array(
            'test_overridden' => array('resize' => array('width'=>200, 'height'=>200)),
            'test_not_overridden' => array('resize' => array('width'=>100, 'height'=>100)),
        ), $config['transformations']);
    }

    /**
     * @dataProvider getTransformationData
     */
    public function testTransformationConfiguration($transformationConfig, $processedTransformation)
    {
        $processor = new Processor();
        $config = $processor->processConfiguration(new Configuration(), array(
            array(
                'transformations' => array(
                    'key' => $transformationConfig
                )
            )
        ));

        $this->assertEquals($config['transformations']['key'], $processedTransformation);
    }

    public function getTransformationData()
    {
        return array(
            array(array('fit_in'=>array('width'=>10,'height'=>20)), array('fit_in'=>array('width'=>10,'height'=>20))),
            array(
                array('full_fit_in'=>array('width'=>10,'height'=>20)),
                array('full_fit_in'=>array('width'=>10,'height'=>20))
            ),
            array(array('trim'=>true), array('trim'=>true)),
            array(array('trim'=>'string'), array('trim'=>'string')),
            array(
                array('crop'=>array('top_left_x'=>10,'top_left_y'=>10,'bottom_right_x'=>10,'bottom_right_y'=>10)),
                array('crop'=>array('top_left_x'=>10,'top_left_y'=>10,'bottom_right_x'=>10,'bottom_right_y'=>10))
            ),
            array(
                array('resize'=>array('width'=>'orig','height'=>'orig')),
                array('resize'=>array('width'=>'orig','height'=>'orig'))
            ),
            array(
                array('resize'=>array('width'=>10,'height'=>10)),
                array('resize'=>array('width'=>10,'height'=>10))
            ),
            array(array('halign'=>'left'), array('halign'=>'left')),
            array(array('halign'=>'center'), array('halign'=>'center')),
            array(array('halign'=>'right'), array('halign'=>'right')),
            array(array('valign'=>'top'), array('valign'=>'top')),
            array(array('valign'=>'middle'), array('valign'=>'middle')),
            array(array('valign'=>'bottom'), array('valign'=>'bottom')),
            array(array('smart_crop'=>true), array('smart_crop'=>true)),
            array(array('metadata_only'=>true), array('metadata_only'=>true)),
            array(
                array('filters'=>array( array('name'=>'brightness', 'arguments'=>array('82')) )),
                array('filters'=>array( array('name'=>'brightness', 'arguments'=>array('82')) )),
            ),
        );
    }

    /**
     * @dataProvider getInvalidTypeData
     */
    public function testInvalidType($transformationData)
    {
        self::expectException(InvalidConfigurationException::class);

        $processor = new Processor();
        $configuration = new Configuration();
        $processor->processConfiguration($configuration, array(
            array(
                'transformations' => array(
                    'key' => $transformationData
                )
            )
        ));
    }

    public function getInvalidTypeData($transformationData)
    {
        return array(
            array( array('resize'=>array('width'=>'toto','height'=>10)) ),
            array( array('resize'=>array('width'=>10,'height'=>'toto')) ),
            array( array('resize'=>array('width'=>null,'height'=>'toto')) ),
            array( array('resize'=>array('width'=>10,'height'=>null)) ),
            array( array('valign'=>10) ),
            array( array('valign'=>null) ),
            array( array('halign'=>10) ),
            array( array('halign'=>null) ),
        );
    }

    /**
     * Get bundle default config
     *
     * @return array
     */
    protected static function getBundleDefaultConfig()
    {
        return array(
            'server' => array(
                'url' => '%env(THUMBOR_URL)%',
                'secret' => '%env(THUMBOR_SECURITY_KEY)%'
            ),
            'transformations' => array()
        );
    }
}


text:
hive
===

下载
---

    https://archive.apache.org/dist/hive/

    国内源
    https://mirror.bit.edu.cn/apache/hive/

本地安装
---

解压后导入环境变量

    export HIVE_HOME="/opt/projects/libs/apache-hive-2.3.7-bin"
    export PATH="$PATH:$HIVE_HOME/bin"

https://cwiki.apache.org/confluence/display/Hive/GettingStarted

		export HADOOP_HOME=<hadoop-install-dir>

		$HADOOP_HOME/bin/hadoop fs -mkdir       /tmp
		$HADOOP_HOME/bin/hadoop fs -mkdir       /user/hive/warehouse
		$HADOOP_HOME/bin/hadoop fs -chmod g+w   /tmp
		$HADOOP_HOME/bin/hadoop fs -chmod g+w   /user/hive/warehouse

配置 metadata

		cp $HIVE_HOME/conf/hive-default.xml.template   $HIVE_HOME/conf/hive-site.xml

添加这几段

		<property>
			<name>system:java.io.tmpdir</name>
			<value>/tmp/hive/java</value>
		</property>
		<property>
			<name>system:user.name</name>
			<value>${user.name}</value>
		</property>

修改 metadata 数据库到 mysql

		<property>
			<name>javax.jdo.option.ConnectionURL</name>
			<value>jdbc:mysql://localhost:3306/hive_metastore</value>
			<description>
				JDBC connect string for a JDBC metastore.
				To use SSL to encrypt/authenticate the connection, provide database-specific SSL flag in the connection URL.
				For example, jdbc:postgresql://myhost/db?ssl=true for postgres database.
			</description>
		<property>
			<name>javax.jdo.option.ConnectionPassword</name>
			<value>hivepassword</value>
			<description>password to use against metastore database</description>
		</property>
		<property>
			<name>javax.jdo.option.ConnectionUserName</name>
			<value>hive</value>
			<description>Username to use against metastore database</description>
		</property>
		<property>
			<name>javax.jdo.option.ConnectionDriverName</name>
			<value>com.mysql.jdbc.Driver</value>
			<description>Driver class name for a JDBC metastore</description>
		</property>

mysql 创建表

		CREATE USER 'hive'@'%' IDENTIFIED BY 'hivepassword';
		create database hive_metastore;
		GRANT ALL ON hive_metastore.* TO 'hive'@'%';
		flush privileges;

将正确版本的mysql-mysql-connector-java.jar 放到 $HIVE_HOME/lib中

初始化metadata表

		schematool -dbType mysql -initSchema

观察是否安装正常

    hive

使用外部表
---

当一个目录下有一堆相同类型的csv时, 似乎需要制定文件夹而不是某个csv,LOCATION默认是hdfs,与hdfs:///testhive 类似

	CREATE EXTERNAL TABLE IF NOT EXISTS hive_test(
		  Id1 STRING, Id2 STRING, Id3 STRING, Name STRING)
		  ROW FORMAT DELIMITED
		  FIELDS TERMINATED BY ','
		  STORED AS TEXTFILE
		  LOCATION '/testhive';

这样可以直接select *

拷贝一个表的内容
---
例如需要拷贝的表为 hive_test

1. 观察表结构

    show create table hive_test;

2. 将第一步的result表名字改成要拷贝的表名创建hive表, 例如 export_hive_test

3. 插入数据

    insert into export_hive_test select * from hive_test;

bash执行hive短句
----

    hive -S -e 'show create table hive_test'

bash通过文件执行sql
---

    hive -f /tmp/hive_test.sql


text:
package com.cflint;

import static org.junit.Assert.assertEquals;

import java.util.List;

import org.junit.Before;
import org.junit.Test;

import com.cflint.api.CFLintAPI;
import com.cflint.api.CFLintResult;
import com.cflint.config.ConfigBuilder;
import com.cflint.exception.CFLintScanException;

public class TestCFBugs_ArgsUse {

    StackHandler handler = null;
    private CFLintAPI cfBugs;

    @Before
    public void setUp() throws Exception {
        final ConfigBuilder configBuilder = new ConfigBuilder().include("ARG_VAR_CONFLICT","ARG_VAR_MIXED");
        cfBugs = new CFLintAPI(configBuilder.build());
    }

    @Test
    public void testVarAndArgs() throws CFLintScanException {
        final String cfcSrc = "<cfcomponent>\r\n" + "<cffunction name=\"test\">\r\n"
                + "	<cfargument name=\"xyz\" default=\"\">\r\n" + "	<cfset var xyz=123/>\r\n" + "</cffunction>\r\n"
                + "</cfcomponent>";
        CFLintResult lintresult = cfBugs.scan(cfcSrc, "test");
        List<BugInfo> result = lintresult.getIssues().values().iterator().next();
        assertEquals(1, result.size());
        assertEquals("ARG_VAR_CONFLICT", result.get(0).getMessageCode());
        assertEquals(4, result.get(0).getLine());
    }

    @Test
    public void testVarAndArgs_Cfscript() throws CFLintScanException {
        final String cfcSrc = "component { \r\n" + "public void function foo(any arg1=\"\") { \r\n"
                + "var arg1=123; \r\n" + "} \r\n" + "}";
        CFLintResult lintresult = cfBugs.scan(cfcSrc, "test");
        List<BugInfo> result = lintresult.getIssues().values().iterator().next();
        assertEquals(1, result.size());
        assertEquals("ARG_VAR_CONFLICT", result.get(0).getMessageCode());
        assertEquals(3, result.get(0).getLine());
    }

    @Test
    public void testVarAndArgs_OK() throws CFLintScanException {
        final String cfcSrc = "<cfcomponent>\r\n" + "<cffunction name=\"test\">\r\n"
                + "	<cfargument name=\"xyz\" default=\"\">\r\n" + "	<cfset xyz=123/>\r\n" + "</cffunction>\r\n"
                + "</cfcomponent>";
        CFLintResult lintresult = cfBugs.scan(cfcSrc, "test");
        assertEquals(0, lintresult.getIssues().size());
    }

    @Test
    public void testVarAndArgs_Struct() throws CFLintScanException {
        final String cfcSrc = "<cfcomponent>\r\n" + "<cffunction name=\"test\">\r\n"
                + "	<cfargument name=\"page\" default=\"\">\r\n"
                + "	<cfset variables.instance.page = arguments.page />\r\n" + "</cffunction>\r\n"
                + "</cfcomponent>";
        CFLintResult lintresult = cfBugs.scan(cfcSrc, "test");
        assertEquals(lintresult.getIssues().toString(), 0, lintresult.getIssues().size());
    }

    @Test
    public void testVarAndArgs_Cfscript_OK() throws CFLintScanException {
        final String cfcSrc = "component { \r\n" + "public void function foo(any arg1=\"\") { \r\n" + "arg1=123; \r\n"
                + "} \r\n" + "}";
        CFLintResult lintresult = cfBugs.scan(cfcSrc, "test");
        assertEquals(0, lintresult.getIssues().size());
    }

    @Test
    public void testVarAndArgs_MixedUse() throws CFLintScanException {
        final String cfcSrc = "<cfcomponent>\r\n" + "<cffunction name=\"test\">\r\n"
                + "	<cfargument name=\"xyz\" default=\"\">\r\n" + "	<cfset xyz=123/>\r\n"
                + "	<cfset y=arguments.xyz/>\r\n" + "</cffunction>\r\n" + "</cfcomponent>";
        CFLintResult lintresult = cfBugs.scan(cfcSrc, "test");
        List<BugInfo> result = lintresult.getIssues().values().iterator().next();
        assertEquals(1, result.size());
        assertEquals("ARG_VAR_MIXED", result.get(0).getMessageCode());
        assertEquals(5, result.get(0).getLine());
    }

    @Test
    public void testVarAndArgs_MixedUse_2x() throws CFLintScanException {
        final String cfcSrc = "<cfcomponent>\r\n" + "<cffunction name=\"test\">\r\n"
                + "	<cfargument name=\"xyz\" default=\"\">\r\n" + "	<cfset xyz=123/>\r\n"
                + "	<cfset y=arguments.xyz/>\r\n" + "	<cfset z=arguments.xyz/>\r\n" + "</cffunction>\r\n"
                + "</cfcomponent>";
        CFLintResult lintresult = cfBugs.scan(cfcSrc, "test");
        List<BugInfo> result = lintresult.getIssues().values().iterator().next();
        assertEquals(1, result.size());
        assertEquals("ARG_VAR_MIXED", result.get(0).getMessageCode());
        assertEquals(5, result.get(0).getLine());
    }
}


text:
'use strict';

var _ = require('lodash');
var Holodeck = require('../../../holodeck');
var Request = require('../../../../../lib/http/request');
var Response = require('../../../../../lib/http/response');
var Twilio = require('../../../../../lib');

var client;
var holodeck;

describe('RatePlan', function() {
  beforeEach(function() {
    holodeck = new Holodeck();
    client = new Twilio('ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'AUTHTOKEN', holodeck);
  });
  it('should generate valid list request',
    function() {
      holodeck.mock(new Response(500, ''));

      var promise = client.preview.wireless.ratePlans.list();
      promise = promise.then(function() {
        throw new Error('failed');
      }, function(error) {
        expect(error.constructor).toBe(Error.prototype.constructor);
      });
      promise.done();

      var url = 'https://preview.twilio.com/wireless/RatePlans';

      holodeck.assertHasRequest(new Request({
        method: 'GET',
        url: url
      }));
    }
  );
  it('should generate valid fetch request',
    function() {
      holodeck.mock(new Response(500, ''));

      var promise = client.preview.wireless.ratePlans('sid').fetch();
      promise = promise.then(function() {
        throw new Error('failed');
      }, function(error) {
        expect(error.constructor).toBe(Error.prototype.constructor);
      });
      promise.done();

      var solution = {
        sid: 'sid'
      };
      var url = _.template('https://preview.twilio.com/wireless/RatePlans/<%= sid %>')(solution);

      holodeck.assertHasRequest(new Request({
        method: 'GET',
        url: url
      }));
    }
  );
});


text:
"""defines class, that describes C++ namespace declaration"""

import declaration
import scopedef
import algorithm

class namespace_t( scopedef.scopedef_t ):
    """
    describes C++ namespace
    """

    def __init__( self, name='', declarations=None ):
        """creates class that describes C++ namespace declaration"""
        scopedef.scopedef_t.__init__( self, name )
        if not declarations:
            declarations = []
        self._declarations = declarations # list of all declarations belongs to this namespace

    def __str__(self):
        name = algorithm.full_name(self)
        if name!="::" and name[:2]=="::":
            name = name[2:]
        return "%s [namespace]"%name

    def _get__cmp__scope_items(self):
        """implementation details"""
        return [ self._sorted_list( self.declarations ) ]

    def _get_declarations_impl(self):
        return self._declarations
    def _set_declarations(self, declarations):
        self._declarations = declarations
    declarations = property( scopedef.scopedef_t._get_declarations
                             , _set_declarations
                             , doc="list of all declarations, defined in the namespace")

    def take_parenting( self, inst ):
        """Takes parenting from inst and transfers it to self"""
        if self is inst:
            return
        for decl in inst.declarations:
            decl.parent = self
            self.declarations.append( decl )
        inst.declarations = []

    def adopt_declaration( self, decl ):
        self.declarations.append( decl )
        decl.parent = self
        decl.cache.reset()

    def remove_declaration( self, decl ):
        """
        removes decl from  members list

        @param decl: declaration to be removed
        @type decl: L{declaration_t}
        """
        del self.declarations[ self.declarations.index( decl ) ]
        decl.cache.reset()
        #add more comment about this.
        #if not keep_parent:
        #    decl.parent=None

    def namespace( self, name=None, function=None, recursive=None ):
        """returns reference to namespace declaration, that is matched defined criterias"""
        return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.namespace ]
                                  , name=name
                                  , function=function
                                  , recursive=recursive )
    ns = namespace

    def namespaces( self, name=None, function=None, recursive=None, allow_empty=None ):
        """returns a set of namespace declarations, that are matched defined criterias"""
        return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.namespace ]
                                    , name=name
                                    , function=function
                                    , recursive=recursive
                                    , allow_empty=allow_empty)
    nss = namespaces

    def free_function( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
        """returns reference to free function declaration, that is matched defined criterias"""
        return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.free_function ]
                                  , name=name
                                  , function=function
                                  , decl_type=self._impl_decl_types[ namespace_t.free_function ]
                                  , return_type=return_type
                                  , arg_types=arg_types
                                  , header_dir=header_dir
                                  , header_file=header_file
                                  , recursive=recursive )
    free_fun = free_function

    def free_functions( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
        """returns a set of free function declarations, that are matched defined criterias"""
        return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.free_function ]
                                    , name=name
                                    , function=function
                                    , decl_type=self._impl_decl_types[ namespace_t.free_function ]
                                    , return_type=return_type
                                    , arg_types=arg_types
                                    , header_dir=header_dir
                                    , header_file=header_file
                                    , recursive=recursive
                                    , allow_empty=allow_empty)
    free_funs = free_functions

    def free_operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
        """returns reference to free operator declaration, that is matched defined criterias"""
        return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.free_operator ]
                                  , name=self._build_operator_name( name, function, symbol )
                                  , symbol=symbol
                                  , function=self._build_operator_function( name, function )
                                  , decl_type=self._impl_decl_types[ namespace_t.free_operator ]
                                  , return_type=return_type
                                  , arg_types=arg_types
                                  , header_dir=header_dir
                                  , header_file=header_file
                                  , recursive=recursive )

    def free_operators( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
        """returns a set of free operator declarations, that are matched defined criterias"""
        return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.free_operator ]
                                    , name=self._build_operator_name( name, function, symbol )
                                    , symbol=symbol
                                    , function=self._build_operator_function( name, function )
                                    , decl_type=self._impl_decl_types[ namespace_t.free_operator ]
                                    , return_type=return_type
                                    , arg_types=arg_types
                                    , header_dir=header_dir
                                    , header_file=header_file
                                    , recursive=recursive
                                    , allow_empty=allow_empty)

    def i_depend_on_them( self, recursive=True ):
        answer = []
        if recursive:
            map( lambda decl: answer.extend( decl.i_depend_on_them() ), self.declarations )
        return answer


text:
@interface FTNoMenuTextView : UITextView {

}

@end


text:
HTML app to be served by puddle-server

###Features:

    [ ] Working version of editor, navigator using same render as before
    [ ] Built on top of puddle-hub

###Installation:

    npm start               # will build everything into ./build folder alias for `gulp`

    npm run develop         # same as above but with source maps and file watcher
                            # to rebuild every time there is a change
###Usage:

To debug on the client using [debug module](https://github.com/visionmedia/debug#browser-support)
type in your browser console and refresh the browser:

    debug.enable('puddle:*')

## Contributors

- Fritz Obermeyer <https://github.com/fritzo>
- Yan T. <https://github.com/yangit>

Puddle was factored out of [Pomagma](https://github.com/fritzo/pomagma) in 2014.

## License

Copyright 2013-2014 Fritz Obermeyer.<br/>
Puddle is licensed under the [MIT license](/LICENSE).


text:
package net.common;

public enum JigProperties {

    /** System Property for local configuration file(s) location outside of 'classpath/config' */
    JIG_LOCATION("jig.location"),
    /** A remote URL based location with config files */
    JIG_URL_LOCATION("jig.url"),
    /** Global overrides entered as JVM args. Ex: jig.entry.foo=bar */
    JIG_COMMAND_LINE_PROP("jig.entry"),
    /** A config file suffix to support environment specific configurations  */
    JIG_FILE_ENVIRONMENT("jig.file.env")
    ;

    private final String _systemPropertyName;

    JigProperties(String systemPropertyName) {
        _systemPropertyName = systemPropertyName;
    }

    public String getName() {
        return _systemPropertyName;
    }
}


text:
using System;
using System.Globalization;
using Nancy;
using Sitecore.Ship.Core.Contracts;

namespace Sitecore.Ship
{
    public abstract class ShipBaseModule : NancyModule
    {
        private readonly IAuthoriser _authoriser;

        const string StartTime = "start_time";

        protected ShipBaseModule(IAuthoriser authoriser, string modulePath)
            : base(modulePath)
        {
            _authoriser = authoriser;

            Before += AuthoriseRequest;

            Before += ctx =>
            {
                ctx.Items.Add(StartTime, DateTime.UtcNow);
                return null;
            };

            After += AddProcessingTimeToResponse;
        }

        private Response AuthoriseRequest(NancyContext ctx)
        {
            return !_authoriser.IsAllowed()
                        ? new Response { StatusCode = HttpStatusCode.Unauthorized }
                        : null;
        }

        private static void AddProcessingTimeToResponse(NancyContext ctx)
        {
            if (!ctx.Items.ContainsKey(StartTime)) return;

            var processTime = (DateTime.UtcNow - (DateTime)ctx.Items[StartTime]).TotalMilliseconds;

            ctx.Response.WithHeader("x-processing-time", processTime.ToString(CultureInfo.InvariantCulture));
        }
    }
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <meta name="description" content="">
    <meta name="author" content="">
    <link rel="icon" href="/assets/favicon.png">
    @isset(config('app.site')->name)
      <title>{{ config('app.site')->name }}</title>
    @endisset

    <link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">

    <link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet">

    <link href="/assets/css/graphene.css" rel="stylesheet">

    @if( request()->input('topbar') !== 'false' )

          <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
            Toggle navigation

          </button>

          @isset(config('app.site')->name)
            {{ config('app.site')->name }}
          @endisset

              @if(Auth::check())

                email) }}?d=mm" />
                {{ Auth::user()->first_name }} {{ Auth::user()->last_name }}

 Dashboard

                @can('visit_admin', 'App\User')

 Admin

                @endcan

 Logout

              @else

                 Guest

 Login

              @endif

            HELLO WORLD

          @yield('titlebar')

    @endif

    @yield('sidemenu')

          @yield('content')

    @yield('bottom_page_scripts')


text: """ migrate data to new database from oracle, ms sql, postgresql or mysql"""


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Artemisa OnLine | Gestion para la salud</title>
<meta name="description" content="Salud" />
<meta name="keywords" content="salud, gestion" />
<link rel="stylesheet" type="text/css" media="all" href="style.css" />

Principal

Presentacion

Clientes

Galeria

Contactenos

Sus Pacientes

                Conozca el estado de cada uno de sus pacientes con solo un click. Siga su progreso ahorrandose tiempo y molestias, mejore su expericia laboral y profesional.

Con una unica carga de datos, genere toda la información que ud necesite.

                Es totalmente confiable y representa exactamente lo que ud quiere y necesita.

									Conozca más

Plantel Medico

                Tenga toda la información necesaria de sus profesionales

                Configure los aspectos mas importanes que a ud le interesa ver.
Un simple click y sus datos personales, especialidades y bancarios apareceran frente a ud.
 Ademas, contamos con una novedosa herramienta: mapa georeferencial de google.

										Conozca más

Obra Social, Prepaga y Financiadores

                Nosotros comprendemos sus necesidades! Es por ello que creamos Artemisa, para simplificarle la toma de decisiones en cuanto a sus financiadores. Mantenga registro de cada uno los ingresos y organicelo a su manera.
Con una única carga genere toda la información que necesita.

											Conozca más

 Consultorios e Internaciones

                Usted eliga su propio tamaño! Lo proveemos con una gran variedad de opciones para que se adapten como anillo al dedo a su negocio.

Gracias a su programacion online, Poseidon le ofrece herramientas y opciones para que su negocio crezca y nunca este falto de infraestructura.

                  Conozca más

Medicamentos y Descartables

                No se pierda el minimo detalle! Adquiera conocimiento sobre todos sus proveedores haciendo mas eficiente su administracion.

 Mediante Artemisa usted podra mantener el control y el stock de todos los materiales necesarios para que su clinica sea fructifera.

 De esa forma nunca estara desorientado y siempre ubicara su Norte!

									Conozca más

Lastest news:

Datos geograficos completos con Google maps.

				GET IN TOUCH

Tailor made development

						In our long history, we have learnt how to satisfy our clients, so that is why our developments will suit you perfectly.

						+ read more

Products and Services

						In APSystem, we can provide you the whole package, the software itself and all the services around it.

						+ read more

Coaching

						As you know, we have travelled through a long way since our start. All that luggage is what we have to offer.

						+ read more

Pages

Home

Presentation

Customers

Blog

Projects

Gallery

Our Team

Contact

Contact Informations

Helguera 4847 of. 1 City:Buenos Aires / Country:Argentine

+54 (011) 4573 4409 & +54 (011) 4573 4409

info@ap-sys.com.ar & helper@ap-sys.com.ar

APSystems

Copyright (c) 2014 APSystems - Developing your future - All Rights Reserved

Questions? Feedback? powered by Olark live chat software


text:
if [ -z $1 -o -z $2 ]
then
	echo "Usage ./generateTSV.sh [Workload File] [Results Dir]"
	exit 1
fi

HEADER="# C/T	URI	Lens	Limit"
for file in `ls $2/response_times_*`
do
	HEADER="$HEADER	`basename $file .txt`"
done

HEADER="$HEADER	triple_count_pharmacology"

for file in `ls $2/mappings_count_*`
do
        HEADER="$HEADER	`basename $file .txt`"
done

for file in `ls $2/mappings_URIs_*`
do
        HEADER="$HEADER	`basename $file .txt`"
done

echo -e "$HEADER"
paste <(grep -v ^# $1) $2/response_times_* $2/triple_count_pharmacology.txt $2/mappings_count_* $2/mappings_URIs_*


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>MagickCore: configure.h File Reference</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
<link href="tabs.css" rel="stylesheet" type="text/css">

magick

configure.h File Reference

#include "magick/hashmap.h"

Go to the source code of this file.

Data Structures

struct  	_ConfigureInfo

Typedefs

typedef struct _ConfigureInfo 	ConfigureInfo

Functions

MagickExport char ** 	GetConfigureList (const char *, unsigned long *, ExceptionInfo *)

MagickExport const char * 	GetConfigureValue (const ConfigureInfo *)

MagickExport const ConfigureInfo * 	GetConfigureInfo (const char *, ExceptionInfo *)

MagickExport const

ConfigureInfo *** 	GetConfigureInfoList (const char *, unsigned long *, ExceptionInfo *)

MagickExport LinkedListInfo * 	DestroyConfigureOptions (LinkedListInfo *)

MagickExport LinkedListInfo ** 	GetConfigurePaths (const char *, ExceptionInfo *)

MagickExport LinkedListInfo *** 	GetConfigureOptions (const char *, ExceptionInfo *)

MagickExport MagickBooleanType 	ListConfigureInfo (FILE *, ExceptionInfo *)

MagickExport void 	DestroyConfigureList (void)

Typedef Documentation

          typedef struct _ConfigureInfo  ConfigureInfo

Function Documentation

          MagickExport void DestroyConfigureList
          (
          void

           )

          MagickExport LinkedListInfo* DestroyConfigureOptions
          (
          LinkedListInfo *

           )

          MagickExport const ConfigureInfo* GetConfigureInfo
          (
          const char *
          ,

          ExceptionInfo *

          )

          MagickExport const ConfigureInfo* ** GetConfigureInfoList
          (
          const char *
          ,

          unsigned long *
          ,

          ExceptionInfo *

          )

          MagickExport char** GetConfigureList
          (
          const char *
          ,

          unsigned long *
          ,

          ExceptionInfo *

          )

          MagickExport LinkedListInfo* * * GetConfigureOptions
          (
          const char *
          ,

          ExceptionInfo *

          )

          MagickExport LinkedListInfo* * GetConfigurePaths
          (
          const char *
          ,

          ExceptionInfo *

          )

          MagickExport const char* GetConfigureValue
          (
          const ConfigureInfo *

           )

          MagickExport MagickBooleanType ListConfigureInfo
          (
          FILE *
          ,

          ExceptionInfo *

          )

<address style="text-align: right;">Generated on Sat Jan 26 14:50:29 2008 for MagickCore by

 1.5.4 </address>


text:
export { default } from './LocalizationProvider';
export type { LocalizationProviderProps } from '@mui/x-date-pickers/LocalizationProvider';


text:
#ifndef QLIST_H
#define QLIST_H

#include <QtCore/qalgorithms.h>
#include <QtCore/qiterator.h>
#include <QtCore/qrefcount.h>

#include <iterator>
#include <list>
#include <algorithm>
#ifdef Q_COMPILER_INITIALIZER_LISTS
#include <initializer_list>
#endif

#include <stdlib.h>
#include <new>
#include <limits.h>
#include <string.h>

QT_BEGIN_NAMESPACE

template <typename T> class QVector;
template <typename T> class QSet;

struct Q_CORE_EXPORT QListData {
    struct Data {
        QtPrivate::RefCount ref;
        int alloc, begin, end;
        void *array[1];
    };
    enum { DataHeaderSize = sizeof(Data) - sizeof(void *) };

    Data *detach(int alloc);
    Data *detach_grow(int *i, int n);
    void realloc(int alloc);
    inline void dispose() { dispose(d); }
    static void dispose(Data *d);
    static const Data shared_null;
    Data *d;
    void **erase(void **xi);
    void **append(int n);
    void **append();
    void **append(const QListData &l);
    void **prepend();
    void **insert(int i);
    void remove(int i);
    void remove(int i, int n);
    void move(int from, int to);
    inline int size() const { return d->end - d->begin; }
    inline bool isEmpty() const { return d->end  == d->begin; }
    inline void **at(int i) const { return d->array + d->begin + i; }
    inline void **begin() const { return d->array + d->begin; }
    inline void **end() const { return d->array + d->end; }
};

template <typename T>
class QList
{
    struct Node { void *v;
#if defined(Q_CC_BOR)
        Q_INLINE_TEMPLATE T &t();
#else
        Q_INLINE_TEMPLATE T &t()
        { return *reinterpret_cast<T*>(QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic
                                       ? v : this); }
#endif
    };

    union { QListData p; QListData::Data *d; };

public:
    inline QList() : d(const_cast<QListData::Data *>(&QListData::shared_null)) { }
    QList(const QList<T> &l);
    ~QList();
    QList<T> &operator=(const QList<T> &l);
#ifdef Q_COMPILER_RVALUE_REFS
    inline QList(QList<T> &&other) : d(other.d) { other.d = const_cast<QListData::Data *>(&QListData::shared_null); }
    inline QList &operator=(QList<T> &&other)
    { qSwap(d, other.d); return *this; }
#endif
    inline void swap(QList<T> &other) { qSwap(d, other.d); }
#ifdef Q_COMPILER_INITIALIZER_LISTS
    inline QList(std::initializer_list<T> args)
        : d(const_cast<QListData::Data *>(&QListData::shared_null))
    { std::copy(args.begin(), args.end(), std::back_inserter(*this)); }
#endif
    bool operator==(const QList<T> &l) const;
    inline bool operator!=(const QList<T> &l) const { return !(*this == l); }

    inline int size() const { return p.size(); }

    inline void detach() { if (d->ref.isShared()) detach_helper(); }

    inline void detachShared()
    {
        // The "this->" qualification is needed for GCCE.
        if (d->ref.isShared() && this->d != &QListData::shared_null)
            detach_helper();
    }

    inline bool isDetached() const { return !d->ref.isShared(); }
    inline void setSharable(bool sharable)
    {
        if (sharable == d->ref.isSharable())
            return;
        if (!sharable)
            detach();
        if (d != &QListData::shared_null)
            d->ref.setSharable(sharable);
    }
    inline bool isSharedWith(const QList<T> &other) const { return d == other.d; }

    inline bool isEmpty() const { return p.isEmpty(); }

    void clear();

    const T &at(int i) const;
    const T &operator[](int i) const;
    T &operator[](int i);

    void reserve(int size);
    void append(const T &t);
    void append(const QList<T> &t);
    void prepend(const T &t);
    void insert(int i, const T &t);
    void replace(int i, const T &t);
    void removeAt(int i);
    int removeAll(const T &t);
    bool removeOne(const T &t);
    T takeAt(int i);
    T takeFirst();
    T takeLast();
    void move(int from, int to);
    void swap(int i, int j);
    int indexOf(const T &t, int from = 0) const;
    int lastIndexOf(const T &t, int from = -1) const;
    bool contains(const T &t) const;
    int count(const T &t) const;

    class const_iterator;

    class iterator {
    public:
        Node *i;
        typedef std::random_access_iterator_tag  iterator_category;
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef T *pointer;
        typedef T &reference;

        inline iterator() : i(0) {}
        inline iterator(Node *n) : i(n) {}
        inline iterator(const iterator &o): i(o.i){}
        inline T &operator*() const { return i->t(); }
        inline T *operator->() const { return &i->t(); }
        inline T &operator[](int j) const { return i[j].t(); }
        inline bool operator==(const iterator &o) const { return i == o.i; }
        inline bool operator!=(const iterator &o) const { return i != o.i; }
        inline bool operator<(const iterator& other) const { return i < other.i; }
        inline bool operator<=(const iterator& other) const { return i <= other.i; }
        inline bool operator>(const iterator& other) const { return i > other.i; }
        inline bool operator>=(const iterator& other) const { return i >= other.i; }
#ifndef QT_STRICT_ITERATORS
        inline bool operator==(const const_iterator &o) const
            { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const
            { return i != o.i; }
        inline bool operator<(const const_iterator& other) const
            { return i < other.i; }
        inline bool operator<=(const const_iterator& other) const
            { return i <= other.i; }
        inline bool operator>(const const_iterator& other) const
            { return i > other.i; }
        inline bool operator>=(const const_iterator& other) const
            { return i >= other.i; }
#endif
        inline iterator &operator++() { ++i; return *this; }
        inline iterator operator++(int) { Node *n = i; ++i; return n; }
        inline iterator &operator--() { i--; return *this; }
        inline iterator operator--(int) { Node *n = i; i--; return n; }
        inline iterator &operator+=(int j) { i+=j; return *this; }
        inline iterator &operator-=(int j) { i-=j; return *this; }
        inline iterator operator+(int j) const { return iterator(i+j); }
        inline iterator operator-(int j) const { return iterator(i-j); }
        inline int operator-(iterator j) const { return int(i - j.i); }
    };
    friend class iterator;

    class const_iterator {
    public:
        Node *i;
        typedef std::random_access_iterator_tag  iterator_category;
        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef const T *pointer;
        typedef const T &reference;

        inline const_iterator() : i(0) {}
        inline const_iterator(Node *n) : i(n) {}
        inline const_iterator(const const_iterator &o): i(o.i) {}
#ifdef QT_STRICT_ITERATORS
        inline explicit const_iterator(const iterator &o): i(o.i) {}
#else
        inline const_iterator(const iterator &o): i(o.i) {}
#endif
        inline const T &operator*() const { return i->t(); }
        inline const T *operator->() const { return &i->t(); }
        inline const T &operator[](int j) const { return i[j].t(); }
        inline bool operator==(const const_iterator &o) const { return i == o.i; }
        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
        inline bool operator<(const const_iterator& other) const { return i < other.i; }
        inline bool operator<=(const const_iterator& other) const { return i <= other.i; }
        inline bool operator>(const const_iterator& other) const { return i > other.i; }
        inline bool operator>=(const const_iterator& other) const { return i >= other.i; }
        inline const_iterator &operator++() { ++i; return *this; }
        inline const_iterator operator++(int) { Node *n = i; ++i; return n; }
        inline const_iterator &operator--() { i--; return *this; }
        inline const_iterator operator--(int) { Node *n = i; i--; return n; }
        inline const_iterator &operator+=(int j) { i+=j; return *this; }
        inline const_iterator &operator-=(int j) { i-=j; return *this; }
        inline const_iterator operator+(int j) const { return const_iterator(i+j); }
        inline const_iterator operator-(int j) const { return const_iterator(i-j); }
        inline int operator-(const_iterator j) const { return i - j.i; }
    };
    friend class const_iterator;

    // stl style
    inline iterator begin() { detach(); return reinterpret_cast<Node *>(p.begin()); }
    inline const_iterator begin() const { return reinterpret_cast<Node *>(p.begin()); }
    inline const_iterator cbegin() const { return reinterpret_cast<Node *>(p.begin()); }
    inline const_iterator constBegin() const { return reinterpret_cast<Node *>(p.begin()); }
    inline iterator end() { detach(); return reinterpret_cast<Node *>(p.end()); }
    inline const_iterator end() const { return reinterpret_cast<Node *>(p.end()); }
    inline const_iterator cend() const { return reinterpret_cast<Node *>(p.end()); }
    inline const_iterator constEnd() const { return reinterpret_cast<Node *>(p.end()); }
    iterator insert(iterator before, const T &t);
    iterator erase(iterator pos);
    iterator erase(iterator first, iterator last);

    // more Qt
    typedef iterator Iterator;
    typedef const_iterator ConstIterator;
    inline int count() const { return p.size(); }
    inline int length() const { return p.size(); } // Same as count()
    inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); }
    inline const T& first() const { Q_ASSERT(!isEmpty()); return at(0); }
    T& last() { Q_ASSERT(!isEmpty()); return *(--end()); }
    const T& last() const { Q_ASSERT(!isEmpty()); return at(count() - 1); }
    inline void removeFirst() { Q_ASSERT(!isEmpty()); erase(begin()); }
    inline void removeLast() { Q_ASSERT(!isEmpty()); erase(--end()); }
    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
    QList<T> mid(int pos, int length = -1) const;

    T value(int i) const;
    T value(int i, const T &defaultValue) const;

    // stl compatibility
    inline void push_back(const T &t) { append(t); }
    inline void push_front(const T &t) { prepend(t); }
    inline T& front() { return first(); }
    inline const T& front() const { return first(); }
    inline T& back() { return last(); }
    inline const T& back() const { return last(); }
    inline void pop_front() { removeFirst(); }
    inline void pop_back() { removeLast(); }
    inline bool empty() const { return isEmpty(); }
    typedef int size_type;
    typedef T value_type;
    typedef value_type *pointer;
    typedef const value_type *const_pointer;
    typedef value_type &reference;
    typedef const value_type &const_reference;
    typedef qptrdiff difference_type;

    // comfort
    QList<T> &operator+=(const QList<T> &l);
    inline QList<T> operator+(const QList<T> &l) const
    { QList n = *this; n += l; return n; }
    inline QList<T> &operator+=(const T &t)
    { append(t); return *this; }
    inline QList<T> &operator<< (const T &t)
    { append(t); return *this; }
    inline QList<T> &operator<<(const QList<T> &l)
    { *this += l; return *this; }

    QVector<T> toVector() const;
    QSet<T> toSet() const;

    static QList<T> fromVector(const QVector<T> &vector);
    static QList<T> fromSet(const QSet<T> &set);

    static inline QList<T> fromStdList(const std::list<T> &list)
    { QList<T> tmp; std::copy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }
    inline std::list<T> toStdList() const
    { std::list<T> tmp; std::copy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }

private:
    Node *detach_helper_grow(int i, int n);
    void detach_helper(int alloc);
    void detach_helper();
    void dealloc(QListData::Data *d);

    void node_construct(Node *n, const T &t);
    void node_destruct(Node *n);
    void node_copy(Node *from, Node *to, Node *src);
    void node_destruct(Node *from, Node *to);

    bool isValidIterator(const iterator &i) const
    {
        return (constBegin().i <= i.i) && (i.i <= constEnd().i);
    }
};

#if defined(Q_CC_BOR)
template <typename T>
Q_INLINE_TEMPLATE T &QList<T>::Node::t()
{ return QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic ? *(T*)v:*(T*)this; }
#endif

template <typename T>
Q_INLINE_TEMPLATE void QList<T>::node_construct(Node *n, const T &t)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) n->v = new T(t);
    else if (QTypeInfo<T>::isComplex) new (n) T(t);
#if (defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__IBMCPP__)) && !defined(__OPTIMIZE__)
    // This violates pointer aliasing rules, but it is known to be safe (and silent)
    // in unoptimized GCC builds (-fno-strict-aliasing). The other compilers which
    // set the same define are assumed to be safe.
    else *reinterpret_cast<T*>(n) = t;
#else
    // This is always safe, but penaltizes unoptimized builds a lot.
    else ::memcpy(n, static_cast<const void *>(&t), sizeof(T));
#endif
}

template <typename T>
Q_INLINE_TEMPLATE void QList<T>::node_destruct(Node *n)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) delete reinterpret_cast<T*>(n->v);
    else if (QTypeInfo<T>::isComplex) reinterpret_cast<T*>(n)->~T();
}

template <typename T>
Q_INLINE_TEMPLATE void QList<T>::node_copy(Node *from, Node *to, Node *src)
{
    Node *current = from;
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        QT_TRY {
            while(current != to) {
                current->v = new T(*reinterpret_cast<T*>(src->v));
                ++current;
                ++src;
            }
        } QT_CATCH(...) {
            while (current-- != from)
                delete reinterpret_cast<T*>(current->v);
            QT_RETHROW;
        }

    } else if (QTypeInfo<T>::isComplex) {
        QT_TRY {
            while(current != to) {
                new (current) T(*reinterpret_cast<T*>(src));
                ++current;
                ++src;
            }
        } QT_CATCH(...) {
            while (current-- != from)
                (reinterpret_cast<T*>(current))->~T();
            QT_RETHROW;
        }
    } else {
        if (src != from && to - from > 0)
            memcpy(from, src, (to - from) * sizeof(Node));
    }
}

template <typename T>
Q_INLINE_TEMPLATE void QList<T>::node_destruct(Node *from, Node *to)
{
    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic)
        while(from != to) --to, delete reinterpret_cast<T*>(to->v);
    else if (QTypeInfo<T>::isComplex)
        while (from != to) --to, reinterpret_cast<T*>(to)->~T();
}

template <typename T>
Q_INLINE_TEMPLATE QList<T> &QList<T>::operator=(const QList<T> &l)
{
    if (d != l.d) {
        QList<T> tmp(l);
        tmp.swap(*this);
    }
    return *this;
}
template <typename T>
inline typename QList<T>::iterator QList<T>::insert(iterator before, const T &t)
{
    Q_ASSERT_X(isValidIterator(before), "QList::insert", "The specified iterator argument 'before' is invalid");

    int iBefore = int(before.i - reinterpret_cast<Node *>(p.begin()));
    Node *n = 0;
    if (d->ref.isShared())
        n = detach_helper_grow(iBefore, 1);
    else
        n = reinterpret_cast<Node *>(p.insert(iBefore));
    QT_TRY {
        node_construct(n, t);
    } QT_CATCH(...) {
        p.remove(iBefore);
        QT_RETHROW;
    }
    return n;
}
template <typename T>
inline typename QList<T>::iterator QList<T>::erase(iterator it)
{
    Q_ASSERT_X(isValidIterator(it), "QList::erase", "The specified iterator argument 'it' is invalid");
    if (d->ref.isShared()) {
        int offset = int(it.i - reinterpret_cast<Node *>(p.begin()));
        it = begin(); // implies detach()
        it += offset;
    }
    node_destruct(it.i);
    return reinterpret_cast<Node *>(p.erase(reinterpret_cast<void**>(it.i)));
}
template <typename T>
inline const T &QList<T>::at(int i) const
{ Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::at", "index out of range");
 return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline const T &QList<T>::operator[](int i) const
{ Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::operator[]", "index out of range");
 return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline T &QList<T>::operator[](int i)
{ Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::operator[]", "index out of range");
  detach(); return reinterpret_cast<Node *>(p.at(i))->t(); }
template <typename T>
inline void QList<T>::removeAt(int i)
{ if(i >= 0 && i < p.size()) { detach();
 node_destruct(reinterpret_cast<Node *>(p.at(i))); p.remove(i); } }
template <typename T>
inline T QList<T>::takeAt(int i)
{ Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::take", "index out of range");
 detach(); Node *n = reinterpret_cast<Node *>(p.at(i)); T t = n->t(); node_destruct(n);
 p.remove(i); return t; }
template <typename T>
inline T QList<T>::takeFirst()
{ T t = first(); removeFirst(); return t; }
template <typename T>
inline T QList<T>::takeLast()
{ T t = last(); removeLast(); return t; }

template <typename T>
Q_OUTOFLINE_TEMPLATE void QList<T>::reserve(int alloc)
{
    if (d->alloc < alloc) {
        if (d->ref.isShared())
            detach_helper(alloc);
        else
            p.realloc(alloc);
    }
}

template <typename T>
Q_OUTOFLINE_TEMPLATE void QList<T>::append(const T &t)
{
    if (d->ref.isShared()) {
        Node *n = detach_helper_grow(INT_MAX, 1);
        QT_TRY {
            node_construct(n, t);
        } QT_CATCH(...) {
            --d->end;
            QT_RETHROW;
        }
    } else {
        if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
            Node *n = reinterpret_cast<Node *>(p.append());
            QT_TRY {
                node_construct(n, t);
            } QT_CATCH(...) {
                --d->end;
                QT_RETHROW;
            }
        } else {
            Node *n, copy;
            node_construct(&copy, t); // t might be a reference to an object in the array
            QT_TRY {
                n = reinterpret_cast<Node *>(p.append());;
            } QT_CATCH(...) {
                node_destruct(&copy);
                QT_RETHROW;
            }
            *n = copy;
        }
    }
}

template <typename T>
inline void QList<T>::prepend(const T &t)
{
    if (d->ref.isShared()) {
        Node *n = detach_helper_grow(0, 1);
        QT_TRY {
            node_construct(n, t);
        } QT_CATCH(...) {
            ++d->begin;
            QT_RETHROW;
        }
    } else {
        if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
            Node *n = reinterpret_cast<Node *>(p.prepend());
            QT_TRY {
                node_construct(n, t);
            } QT_CATCH(...) {
                ++d->begin;
                QT_RETHROW;
            }
        } else {
            Node *n, copy;
            node_construct(&copy, t); // t might be a reference to an object in the array
            QT_TRY {
                n = reinterpret_cast<Node *>(p.prepend());;
            } QT_CATCH(...) {
                node_destruct(&copy);
                QT_RETHROW;
            }
            *n = copy;
        }
    }
}

template <typename T>
inline void QList<T>::insert(int i, const T &t)
{
    if (d->ref.isShared()) {
        Node *n = detach_helper_grow(i, 1);
        QT_TRY {
            node_construct(n, t);
        } QT_CATCH(...) {
            p.remove(i);
            QT_RETHROW;
        }
    } else {
        if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
            Node *n = reinterpret_cast<Node *>(p.insert(i));
            QT_TRY {
                node_construct(n, t);
            } QT_CATCH(...) {
                p.remove(i);
                QT_RETHROW;
            }
        } else {
            Node *n, copy;
            node_construct(&copy, t); // t might be a reference to an object in the array
            QT_TRY {
                n = reinterpret_cast<Node *>(p.insert(i));;
            } QT_CATCH(...) {
                node_destruct(&copy);
                QT_RETHROW;
            }
            *n = copy;
        }
    }
}

template <typename T>
inline void QList<T>::replace(int i, const T &t)
{
    Q_ASSERT_X(i >= 0 && i < p.size(), "QList<T>::replace", "index out of range");
    detach();
    reinterpret_cast<Node *>(p.at(i))->t() = t;
}

template <typename T>
inline void QList<T>::swap(int i, int j)
{
    Q_ASSERT_X(i >= 0 && i < p.size() && j >= 0 && j < p.size(),
                "QList<T>::swap", "index out of range");
    detach();
    void *t = d->array[d->begin + i];
    d->array[d->begin + i] = d->array[d->begin + j];
    d->array[d->begin + j] = t;
}

template <typename T>
inline void QList<T>::move(int from, int to)
{
    Q_ASSERT_X(from >= 0 && from < p.size() && to >= 0 && to < p.size(),
               "QList<T>::move", "index out of range");
    detach();
    p.move(from, to);
}

template<typename T>
Q_OUTOFLINE_TEMPLATE QList<T> QList<T>::mid(int pos, int alength) const
{
    if (alength < 0 || pos > size() - alength)
        alength = size() - pos;
    if (pos == 0 && alength == size())
        return *this;
    QList<T> cpy;
    if (alength <= 0)
        return cpy;
    cpy.reserve(alength);
    cpy.d->end = alength;
    QT_TRY {
        cpy.node_copy(reinterpret_cast<Node *>(cpy.p.begin()),
                      reinterpret_cast<Node *>(cpy.p.end()),
                      reinterpret_cast<Node *>(p.begin() + pos));
    } QT_CATCH(...) {
        // restore the old end
        cpy.d->end = 0;
        QT_RETHROW;
    }
    return cpy;
}

template<typename T>
Q_OUTOFLINE_TEMPLATE T QList<T>::value(int i) const
{
    if (i < 0 || i >= p.size()) {
        return T();
    }
    return reinterpret_cast<Node *>(p.at(i))->t();
}

template<typename T>
Q_OUTOFLINE_TEMPLATE T QList<T>::value(int i, const T& defaultValue) const
{
    return ((i < 0 || i >= p.size()) ? defaultValue : reinterpret_cast<Node *>(p.at(i))->t());
}

template <typename T>
Q_OUTOFLINE_TEMPLATE typename QList<T>::Node *QList<T>::detach_helper_grow(int i, int c)
{
    Node *n = reinterpret_cast<Node *>(p.begin());
    QListData::Data *x = p.detach_grow(&i, c);
    QT_TRY {
        node_copy(reinterpret_cast<Node *>(p.begin()),
                  reinterpret_cast<Node *>(p.begin() + i), n);
    } QT_CATCH(...) {
        p.dispose();
        d = x;
        QT_RETHROW;
    }
    QT_TRY {
        node_copy(reinterpret_cast<Node *>(p.begin() + i + c),
                  reinterpret_cast<Node *>(p.end()), n + i);
    } QT_CATCH(...) {
        node_destruct(reinterpret_cast<Node *>(p.begin()),
                      reinterpret_cast<Node *>(p.begin() + i));
        p.dispose();
        d = x;
        QT_RETHROW;
    }

    if (!x->ref.deref())
        dealloc(x);

    return reinterpret_cast<Node *>(p.begin() + i);
}

template <typename T>
Q_OUTOFLINE_TEMPLATE void QList<T>::detach_helper(int alloc)
{
    Node *n = reinterpret_cast<Node *>(p.begin());
    QListData::Data *x = p.detach(alloc);
    QT_TRY {
        node_copy(reinterpret_cast<Node *>(p.begin()), reinterpret_cast<Node *>(p.end()), n);
    } QT_CATCH(...) {
        p.dispose();
        d = x;
        QT_RETHROW;
    }

    if (!x->ref.deref())
        dealloc(x);
}

template <typename T>
Q_OUTOFLINE_TEMPLATE void QList<T>::detach_helper()
{
    detach_helper(d->alloc);
}

template <typename T>
Q_OUTOFLINE_TEMPLATE QList<T>::QList(const QList<T> &l)
    : d(l.d)
{
    if (!d->ref.ref()) {
        p.detach(d->alloc);

        QT_TRY {
            node_copy(reinterpret_cast<Node *>(p.begin()),
                    reinterpret_cast<Node *>(p.end()),
                    reinterpret_cast<Node *>(l.p.begin()));
        } QT_CATCH(...) {
            QListData::dispose(d);
            QT_RETHROW;
        }
    }
}

template <typename T>
Q_OUTOFLINE_TEMPLATE QList<T>::~QList()
{
    if (!d->ref.deref())
        dealloc(d);
}

template <typename T>
Q_OUTOFLINE_TEMPLATE bool QList<T>::operator==(const QList<T> &l) const
{
    if (p.size() != l.p.size())
        return false;
    if (d == l.d)
        return true;
    Node *i = reinterpret_cast<Node *>(p.end());
    Node *b = reinterpret_cast<Node *>(p.begin());
    Node *li = reinterpret_cast<Node *>(l.p.end());
    while (i != b) {
        --i; --li;
        if (!(i->t() == li->t()))
            return false;
    }
    return true;
}

template <typename T>
Q_OUTOFLINE_TEMPLATE void QList<T>::dealloc(QListData::Data *data)
{
    node_destruct(reinterpret_cast<Node *>(data->array + data->begin),
                  reinterpret_cast<Node *>(data->array + data->end));
    QListData::dispose(data);
}

template <typename T>
Q_OUTOFLINE_TEMPLATE void QList<T>::clear()
{
    *this = QList<T>();
}

template <typename T>
Q_OUTOFLINE_TEMPLATE int QList<T>::removeAll(const T &_t)
{
    int index = indexOf(_t);
    if (index == -1)
        return 0;

    const T t = _t;
    detach();

    Node *i = reinterpret_cast<Node *>(p.at(index));
    Node *e = reinterpret_cast<Node *>(p.end());
    Node *n = i;
    node_destruct(i);
    while (++i != e) {
        if (i->t() == t)
            node_destruct(i);
        else
            *n++ = *i;
    }

    int removedCount = e - n;
    d->end -= removedCount;
    return removedCount;
}

template <typename T>
Q_OUTOFLINE_TEMPLATE bool QList<T>::removeOne(const T &_t)
{
    int index = indexOf(_t);
    if (index != -1) {
        removeAt(index);
        return true;
    }
    return false;
}

template <typename T>
Q_OUTOFLINE_TEMPLATE typename QList<T>::iterator QList<T>::erase(typename QList<T>::iterator afirst,
                                                                 typename QList<T>::iterator alast)
{
    Q_ASSERT_X(isValidIterator(afirst), "QList::erase", "The specified iterator argument 'afirst' is invalid");
    Q_ASSERT_X(isValidIterator(alast), "QList::erase", "The specified iterator argument 'alast' is invalid");

    if (d->ref.isShared()) {
        // ### A block is erased and a detach is needed. We should shrink and only copy relevant items.
        int offsetfirst = int(afirst.i - reinterpret_cast<Node *>(p.begin()));
        int offsetlast = int(alast.i - reinterpret_cast<Node *>(p.begin()));
        afirst = begin(); // implies detach()
        alast = afirst;
        afirst += offsetfirst;
        alast += offsetlast;
    }

    for (Node *n = afirst.i; n < alast.i; ++n)
        node_destruct(n);
    int idx = afirst - begin();
    p.remove(idx, alast - afirst);
    return begin() + idx;
}

template <typename T>
Q_OUTOFLINE_TEMPLATE QList<T> &QList<T>::operator+=(const QList<T> &l)
{
    if (!l.isEmpty()) {
        if (isEmpty()) {
            *this = l;
        } else {
            Node *n = (d->ref.isShared())
                      ? detach_helper_grow(INT_MAX, l.size())
                      : reinterpret_cast<Node *>(p.append(l.p));
            QT_TRY {
                node_copy(n, reinterpret_cast<Node *>(p.end()),
                          reinterpret_cast<Node *>(l.p.begin()));
            } QT_CATCH(...) {
                // restore the old end
                d->end -= int(reinterpret_cast<Node *>(p.end()) - n);
                QT_RETHROW;
            }
        }
    }
    return *this;
}

template <typename T>
inline void QList<T>::append(const QList<T> &t)
{
    *this += t;
}

template <typename T>
Q_OUTOFLINE_TEMPLATE int QList<T>::indexOf(const T &t, int from) const
{
    if (from < 0)
        from = qMax(from + p.size(), 0);
    if (from < p.size()) {
        Node *n = reinterpret_cast<Node *>(p.at(from -1));
        Node *e = reinterpret_cast<Node *>(p.end());
        while (++n != e)
            if (n->t() == t)
                return int(n - reinterpret_cast<Node *>(p.begin()));
    }
    return -1;
}

template <typename T>
Q_OUTOFLINE_TEMPLATE int QList<T>::lastIndexOf(const T &t, int from) const
{
    if (from < 0)
        from += p.size();
    else if (from >= p.size())
        from = p.size()-1;
    if (from >= 0) {
        Node *b = reinterpret_cast<Node *>(p.begin());
        Node *n = reinterpret_cast<Node *>(p.at(from + 1));
        while (n-- != b) {
            if (n->t() == t)
                return n - b;
        }
    }
    return -1;
}

template <typename T>
Q_OUTOFLINE_TEMPLATE bool QList<T>::contains(const T &t) const
{
    Node *b = reinterpret_cast<Node *>(p.begin());
    Node *i = reinterpret_cast<Node *>(p.end());
    while (i-- != b)
        if (i->t() == t)
            return true;
    return false;
}

template <typename T>
Q_OUTOFLINE_TEMPLATE int QList<T>::count(const T &t) const
{
    int c = 0;
    Node *b = reinterpret_cast<Node *>(p.begin());
    Node *i = reinterpret_cast<Node *>(p.end());
    while (i-- != b)
        if (i->t() == t)
            ++c;
    return c;
}

Q_DECLARE_SEQUENTIAL_ITERATOR(List)
Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(List)

QT_END_NAMESPACE

#endif // QLIST_H


text:
package rpc_presure

type Options struct {
	RPCTimes int `flag:"times"`
}

func NewOptions() *Options {

	return &Options{
		RPCTimes: 1000,
	}
}


text:
#ifndef WKAPICastEfl_h
#define WKAPICastEfl_h

#ifndef WKAPICast_h
#error "Please #include \"WKAPICast.h\" instead of this file directly."
#endif

typedef struct _Evas_Object Evas_Object;

namespace WebKit {

WK_ADD_API_MAPPING(WKViewRef, Evas_Object)

}

#endif // WKAPICastEfl_h


text:
package com.ogaclejapan.rx.binding;

import com.ogaclejapan.rx.binding.tuple.Tuple;
import com.ogaclejapan.rx.binding.tuple.Tuple1;
import com.ogaclejapan.rx.binding.tuple.Tuple2;

import android.support.annotation.NonNull;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

import rx.Subscription;

public class RxList<E> extends RxObject<List<E>> implements RxReadOnlyList<E>, List<E> {

    private final RxAction<List<E>, Kind<Event, Tuple>> BIND_ACTION =
            new RxAction<List<E>, Kind<Event, Tuple>>() {
                @Override
                public void call(List<E> list, Kind<Event, Tuple> kind) {
                    switch (kind.type) {
                        case add:
                            Tuple1<E> listAddData = Tuple.of(kind.data);
                            add(list, listAddData.item1);
                            break;
                        case addAt:
                            Tuple2<Integer, E> listAddAtData = Tuple.of(kind.data);
                            add(list, listAddAtData.item1, listAddAtData.item2);
                            break;
                        case addAll:
                            Tuple1<Collection<E>> listAddAllData = Tuple.of(kind.data);
                            addAll(list, listAddAllData.item1);
                            break;
                        case addAllAt:
                            Tuple2<Integer, Collection<E>> listAddAllAtData = Tuple.of(kind.data);
                            addAll(list, listAddAllAtData.item1, listAddAllAtData.item2);
                            break;
                        case clear:
                            clear();
                            break;
                        case removeAt:
                            Tuple1<Integer> listRemoveAtData = Tuple.of(kind.data);
                            remove(list, listRemoveAtData.item1);
                            break;
                        case remove:
                            Tuple1<E> listRemoveData = Tuple.of(kind.data);
                            remove(list, listRemoveData.item1);
                            break;
                        case removeAll:
                            Tuple1<Collection<E>> listRemoveAllData = Tuple.of(kind.data);
                            removeAll(list, listRemoveAllData.item1);
                            break;
                        case retainAll:
                            Tuple1<Collection<E>> listRetainAllData = Tuple.of(kind.data);
                            retainAll(list, listRetainAllData.item1);
                            break;
                        case set:
                            Tuple2<Integer, E> listSetData = Tuple.of(kind.data);
                            set(list, listSetData.item1, listSetData.item2);
                            break;
                        default:
                            return;
                    }

                }
            };

    private final RxEvent<Kind<Event, Tuple>> onDataSetChanged;

    private OnDataSetChangeListener onDataSetChangeListener;

    protected RxList(List<E> list) {
        super(list);
        onDataSetChanged = RxEvent.create();
    }

    public static <E> RxList<E> create() {
        return of(new ArrayList<E>());
    }

    public static <E> RxList<E> of(List<E> initialList) {
        return new RxList<E>(initialList);
    }

    @Override
    public void setOnDataSetChangeListener(final OnDataSetChangeListener listener) {
        this.onDataSetChangeListener = listener;
    }

    @Override
    public boolean add(E e) {
        return add(list(), e);
    }

    @Override
    public void add(int index, E element) {
        add(list(), index, element);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return addAll(list(), c);
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        return addAll(list(), index, c);
    }

    @Override
    public void clear() {
        clear(list());
    }

    @Override
    public E remove(int index) {
        return remove(list(), index);
    }

    @Override
    public boolean remove(Object object) {
        return remove(list(), object);
    }

    @Override
    public boolean removeAll(@NonNull Collection<?> c) {
        return removeAll(list(), c);
    }

    @Override
    public boolean retainAll(@NonNull Collection<?> c) {
        return retainAll(list(), c);
    }

    @Override
    public E set(int index, E element) {
        return set(list(), index, element);
    }

    @NonNull
    @Override
    public Object[] toArray() {
        return list().toArray();
    }

    @NonNull
    @Override
    public <T> T[] toArray(@NonNull T[] array) {
        return list().toArray(array);
    }

    @Override
    public E get(int index) {
        return list().get(index);
    }

    @Override
    public int indexOf(Object object) {
        return list().indexOf(object);
    }

    @Override
    public int lastIndexOf(Object object) {
        return list().lastIndexOf(object);
    }

    @Override
    public boolean isEmpty() {
        return list().isEmpty();
    }

    @Override
    public boolean contains(Object object) {
        return list().contains(object);
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return list().containsAll(c);
    }

    @Override
    public int size() {
        return list().size();
    }

    @NonNull
    @Override
    public Iterator<E> iterator() {
        return list().iterator();
    }

    @NonNull
    @Override
    public ListIterator<E> listIterator() {
        return list().listIterator();
    }

    @NonNull
    @Override
    public ListIterator<E> listIterator(int index) {
        return list().listIterator(index);
    }

    @NonNull
    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        return list().subList(fromIndex, toIndex);
    }

    @Override
    public rx.Observable<Kind<Event, Tuple>> onDataSetChanged() {
        return onDataSetChanged.asObservable();
    }

    @Override
    public Subscription bind(final RxReadOnlyList<E> list) {
        if (list.size() > 0) {
            addAll(list.subList(0, list.size()));
        }
        return bind(list.onDataSetChanged(), BIND_ACTION);
    }

    private List<E> list() {
        return get();
    }

    private void notifyDataSetChanged(Event type, Tuple data) {
        final Kind<Event, Tuple> event = new Kind<Event, Tuple>(type, data);
        onDataSetChanged.post(event);
        if (onDataSetChangeListener != null) {
            onDataSetChangeListener.onDataSetChanged(type);
        }
    }

    private boolean add(List<E> list, E e) {
        final boolean result = list.add(e);
        notifyDataSetChanged(Event.add, Tuple.create(e));
        return result;
    }

    private void add(List<E> list, int index, E element) {
        list.add(index, element);
        notifyDataSetChanged(Event.addAt, Tuple.create(index, element));
    }

    private boolean addAll(List<E> list, Collection<? extends E> c) {
        final boolean result = list.addAll(c);
        notifyDataSetChanged(Event.addAll, Tuple.create(c));
        return result;
    }

    private boolean addAll(List<E> list, int index, Collection<? extends E> c) {
        final boolean result = list.addAll(index, c);
        notifyDataSetChanged(Event.addAllAt, Tuple.create(index, c));
        return result;
    }

    private void clear(List<E> list) {
        list.clear();
        notifyDataSetChanged(Event.clear, Tuple.create());
    }

    private E remove(List<E> list, int index) {
        final E result = list.remove(index);
        notifyDataSetChanged(Event.removeAt, Tuple.create(index));
        return result;
    }

    private boolean remove(List<E> list, Object object) {
        final boolean result = list.remove(object);
        notifyDataSetChanged(Event.remove, Tuple.create(object));
        return result;
    }

    private boolean removeAll(List<E> list, @NonNull Collection<?> c) {
        final boolean result = list.removeAll(c);
        notifyDataSetChanged(Event.removeAll, Tuple.create(c));
        return result;
    }

    private boolean retainAll(List<E> list, @NonNull Collection<?> c) {
        final boolean result = list.retainAll(c);
        notifyDataSetChanged(Event.retainAll, Tuple.create(c));
        return result;
    }

    private E set(List<E> list, int index, E element) {
        final E result = list.set(index, element);
        notifyDataSetChanged(Event.set, Tuple.create(index, element));
        return result;
    }

}


text:
package com.java110.store.bmo.storeMsg.impl;

import com.java110.core.annotation.Java110Transactional;
import com.java110.intf.store.IStoreMsgInnerServiceSMO;
import com.java110.po.storeMsg.StoreMsgPo;
import com.java110.store.bmo.storeMsg.IDeleteStoreMsgBMO;
import com.java110.vo.ResultVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

@Service("deleteStoreMsgBMOImpl")
public class DeleteStoreMsgBMOImpl implements IDeleteStoreMsgBMO {

    @Autowired
    private IStoreMsgInnerServiceSMO storeMsgInnerServiceSMOImpl;

    /**
     * @param storeMsgPo 数据
     * @return 订单服务能够接受的报文
     */
    @Java110Transactional
    public ResponseEntity<String> delete(StoreMsgPo storeMsgPo) {

        int flag = storeMsgInnerServiceSMOImpl.deleteStoreMsg(storeMsgPo);

        if (flag > 0) {
            return ResultVo.createResponseEntity(ResultVo.CODE_OK, "保存成功");
        }

        return ResultVo.createResponseEntity(ResultVo.CODE_ERROR, "保存失败");
    }

}