text:
<!doctype html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="description" content="Triangles jquery plugin Documentation">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Triangles JQuery Plugin</title>

    <meta name="mobile-web-app-capable" content="yes">
    <link rel="icon" sizes="192x192" href="images/touch/chrome-touch-icon-192x192.png">

    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black">
    <meta name="apple-mobile-web-app-title" content="Web Starter Kit">
    <link rel="apple-touch-icon-precomposed" href="apple-touch-icon-precomposed.png">

    <meta name="msapplication-TileImage" content="images/touch/ms-touch-icon-144x144-precomposed.png">
    <meta name="msapplication-TileColor" content="#3372DF">

    <link rel="stylesheet" href="styles/main.css">

        <button class="menu"></button>

Triangles JQuery Plugin

            <button></button>
            <button></button>

Navigation

About

Getting Started

Demo

About

            <svg id="triangles-default" class="triangles"></svg>

            <svg id="triangles-random" class="triangles"></svg>

        This is a jquery plugin that generates triangles pixel-like svg images.

        Check out Demo for colours and love!

Inspiration

        I came across michelle/triangles on Github
        (which comes with an inspiring story)
        and thought it was really cool!

        I played with it and decided to made it into a jquery plugin.
        Initially I mimic the original implementation and generate divs to make the triangles
        before I switch to svg instead for better pixel precision.

Limitation

        Admittedly this is the first time I make a jquery plugin and it isn't perfect.

        Also, there is performance issue when there are too many triangles generated.

        Any feedback and suggestion for improvement are welcomed. :)


text:
module InfinityTest
  module Strategy
    class Base
      def initialize(continuous_test_server)
        @continuous_test_server = continuous_test_server
      end

      # ==== Returns
      # CommandBuilderClass: A class that builds that command using method_missing.
      #
      def command_builder
        Core::CommandBuilder.new
      end

      # Run the strategy and parse the results storing in the strategy.
      #
      def run
        Core::CommandRunner.new(run!)
      end

      # Implement #run! method returning a string command to be run.
      #
      def run!
        raise NotImplementedError, "not implemented in #{self}"
      end

      # Put all the requires to autodiscover use your strategy instead of others.
      #
      def self.run?
        raise NotImplementedError, "not implemented in #{self}"
      end
    end
  end
end

redpajama_set_name: RedPajamaGithub


text: Testing out opsworks' chef integration.


text:
Range
===
[![NPM version][npm-image]][npm-url] [![Build Status][travis-image]][travis-url] [![Coverage Status][coveralls-image]][coveralls-url] [![Dependencies][dependencies-image]][dependencies-url]

> Computes the arithmetic range of an array.

## Installation

``` bash
$ npm install compute-range
```

For use in the browser, use [browserify](https://github.com/substack/node-browserify).

## Usage

``` javascript
var range = require( 'compute-range' );
```

#### range( arr[, accessor] )

Computes the arithmetic range of an `array`. For primitive number `arrays`,

``` javascript
var arr = [ 2, 3, 4, 1 ];

var r = range( arr );
// returns [ 1, 4 ]
```

For object `arrays`, provide an accessor `function` for accessing numeric `array` values

``` javascript
var arr = [
	[1,2],
	[3,3],
	[4,4],
	[6,1]
];

function getValue( d ) {
	return d[ 1 ];
}

var r = range( arr, getValue );
// returns [ 1, 4 ]
```

## Notes

* 	if provided an empty `array`, the function returns `null`.
*	the first value of the returned `array` is always the minimum value and the second value is always the maximum value.

## Examples

``` javascript
var range = require( 'compute-range' );

var data = new Array( 100 );
for ( var i = 0; i < data.length; i++ ) {
	data[ i ] = Math.random() * 100;
}
console.log( range( data ) );
```

To run the example code from the top-level application directory,

``` bash
$ node ./examples/index.js
```

## Tests

### Unit

Unit tests use the [Mocha](http://mochajs.org) test framework with [Chai](http://chaijs.com) assertions. To run the tests, execute the following command in the top-level application directory:

``` bash
$ make test
```

All new feature development should have corresponding unit tests to validate correct functionality.

### Test Coverage

This repository uses [Istanbul](https://github.com/gotwarlost/istanbul) as its code coverage tool. To generate a test coverage report, execute the following command in the top-level application directory:

``` bash
$ make test-cov
```

Istanbul creates a `./reports/coverage` directory. To access an HTML version of the report,

``` bash
$ make view-cov
```

---
## License

[MIT license](http://opensource.org/licenses/MIT).

## Copyright

Copyright © 2014-2015. Athan Reines.

[npm-image]: http://img.shields.io/npm/v/compute-range.svg
[npm-url]: https://npmjs.org/package/compute-range

[travis-image]: http://img.shields.io/travis/compute-io/range/master.svg
[travis-url]: https://travis-ci.org/compute-io/range

[coveralls-image]: https://img.shields.io/coveralls/compute-io/range/master.svg
[coveralls-url]: https://coveralls.io/r/compute-io/range?branch=master

[dependencies-image]: http://img.shields.io/david/compute-io/range.svg
[dependencies-url]: https://david-dm.org/compute-io/range

[dev-dependencies-image]: http://img.shields.io/david/dev/compute-io/range.svg
[dev-dependencies-url]: https://david-dm.org/dev/compute-io/range

[github-issues-image]: http://img.shields.io/github/issues/compute-io/range.svg
[github-issues-url]: https://github.com/compute-io/range/issues


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.ehcache</groupId>
    <artifactId>ehcache-bundle</artifactId>
    <version>3.9.9</version>
    <packaging>bundle</packaging>

    <name>EhCache bundle</name>

    <properties>
        <bundle.category>platform,cache</bundle.category>
        <bundle.name>org.ehcache-bundle</bundle.name>
        <sling.scheme>http</sling.scheme>
        <sling.secure>false</sling.secure>
        <sling.host>localhost</sling.host>
        <sling.port>9090</sling.port>
        <sling.context></sling.context>
        <sling.user>admin</sling.user>
        <sling.password>admin</sling.password>
        <source.encoding>UTF-8</source.encoding>
        <java.source>1.7</java.source>
        <java.target>1.7</java.target>
        <maven.compiler.source>${java.source}</maven.compiler.source>
        <maven.compiler.target>${java.target}</maven.compiler.target>
        <maven.site.skip>true</maven.site.skip>
    </properties>

    <scm>
        <connection>scm:git:https://github.com/ist-dresden/composum-platform.git</connection>
        <developerConnection>scm:git:https://github.com/ist-dresden/composum-platform.git</developerConnection>
        <url>https://github.com/ist-dresden/composum-platform.git</url>
    </scm>

    <distributionManagement>
        <repository>
            <id>istrepo</id>
            <url>https://repo.ist-software.com/repository/maven-releases</url>
        </repository>
        <snapshotRepository>
            <id>istrepo</id>
            <url>https://repo.ist-software.com/repository/maven-snapshots</url>
        </snapshotRepository>
    </distributionManagement>

    <build>
        <plugins>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.0.1</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

            <plugin>
                <groupId>pl.project13.maven</groupId>
                <artifactId>git-commit-id-plugin</artifactId>
            </plugin>

            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-bundle-plugin</artifactId>
                <version>3.3.0</version>
                <extensions>true</extensions>
                <configuration>
                    <instructions>
                        <Bundle-Category>${bundle.category}</Bundle-Category>
                        <Bundle-SymbolicName>${bundle.name}</Bundle-SymbolicName>
                        <Include-Resource>
                            {maven-resources}
                        </Include-Resource>
                        <Export-Package>
                            org.ehcache.*
                        </Export-Package>
                        <Import-Package>
                            sun.misc;resolution:=optional,
                            *
                        </Import-Package>
                        <Embed-Dependency>
                            *;scope=compile|runtime
                        </Embed-Dependency>
                    </instructions>
                </configuration>
            </plugin>

        </plugins>
    </build>
    <dependencies>

        <dependency>
            <groupId>org.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>${project.version}</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>javax.cache</groupId>
            <artifactId>cache-api</artifactId>
            <version>1.0.0</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>javax.enterprise</groupId>
            <artifactId>cdi-api</artifactId>
            <version>2.0</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>javax.interceptor</groupId>
            <artifactId>javax.interceptor-api</artifactId>
            <version>1.2.1</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>3.0.0</version>
            <scope>compile</scope>
        </dependency>

    </dependencies>
    <profiles>

        <profile>
            <id>uploadBundle</id>
            <activation>
                <property>
                    <name>upload.bundle</name>
                    <value>true</value>
                </property>
            </activation>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.apache.sling</groupId>
                        <artifactId>sling-maven-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>install-bundle</id>
                                <phase>install</phase>
                                <goals>
                                    <goal>install</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>

    </profiles>
</project>


text:
<!DOCTYPE html>
<meta charset=utf-8>
<title>Redirecting...</title>
<link rel=canonical href="../廿/index.html">
<meta http-equiv=refresh content="0; url='../廿/index.html'">

Redirecting...

Click here if you are not redirected.


text:
@interface PodsDummy_Pods_FRCircleSlider_Tests : NSObject
@end
@implementation PodsDummy_Pods_FRCircleSlider_Tests
@end


text:
var __extends = this.__extends || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
};
var LdrawVisualizer;
(function (LdrawVisualizer) {
    var Parser;
    (function (Parser) {
        var Lines;
        (function (Lines) {
            var AuthorMETALine = (function (_super) {
                __extends(AuthorMETALine, _super);
                function AuthorMETALine(author) {
                    _super.call(this, Lines.LdrawFileLineType.Author);
                    this.Author = author;
                }
                AuthorMETALine.prototype.IsValid = function () {
                    return LdrawVisualizer.Utility.hasAtLeastOneNonWhitespaceCharacter(this.Author);
                };
                AuthorMETALine.Parse = function (line, splitLine, lineNumber) {
                    var authorLine = new AuthorMETALine(splitLine[2]);
                    if (!authorLine.IsValid()) {
                        throw 'Unable to parse author META line: Invalid line arguments on line ' + lineNumber;
                    }
                    return authorLine;
                };
                return AuthorMETALine;
            })(Lines.LdrawFileLine);
            Lines.AuthorMETALine = AuthorMETALine;
        })(Lines = Parser.Lines || (Parser.Lines = {}));
    })(Parser = LdrawVisualizer.Parser || (LdrawVisualizer.Parser = {}));
})(LdrawVisualizer || (LdrawVisualizer = {}));
//# sourceMappingURL=AuthorMETALine.js.map


text:
package com.opengamma.financial.analytics.model.swaption.black;

import java.util.Collections;
import java.util.Set;

import com.opengamma.OpenGammaRuntimeException;
import com.opengamma.analytics.financial.interestrate.InstrumentDerivative;
import com.opengamma.analytics.financial.interestrate.swaption.method.SwaptionBlackValueThetaCalculator;
import com.opengamma.analytics.financial.model.option.definition.YieldCurveWithBlackSwaptionBundle;
import com.opengamma.engine.value.ComputedValue;
import com.opengamma.engine.value.ValuePropertyNames;
import com.opengamma.engine.value.ValueRequirementNames;
import com.opengamma.engine.value.ValueSpecification;
import com.opengamma.util.money.CurrencyAmount;

/**
 * Calculates value theta of swaptions using the Black method.
 * @deprecated The parent class of this function is deprecated
 */
@Deprecated
public class SwaptionBlackValueThetaFunction extends SwaptionBlackFunction {
  /** The calculator */
  private static final SwaptionBlackValueThetaCalculator CALCULATOR = SwaptionBlackValueThetaCalculator.getInstance();

  /**
   * Sets the value requirement name to {@link ValueRequirementNames#VALUE_THETA}
   */
  public SwaptionBlackValueThetaFunction() {
    super(ValueRequirementNames.VALUE_THETA);
  }

  @Override
  protected Set<ComputedValue> getResult(final InstrumentDerivative swaption, final YieldCurveWithBlackSwaptionBundle data, final ValueSpecification spec) {
    final CurrencyAmount result = swaption.accept(CALCULATOR, data);
    final String resultCurrency = result.getCurrency().getCode();
    final String expectedCurrency = spec.getProperty(ValuePropertyNames.CURRENCY);
    if (!expectedCurrency.equals(resultCurrency)) {
      throw new OpenGammaRuntimeException("Expected currency " + expectedCurrency + " does not equal result currency " + resultCurrency);
    }
    final double thetaValue = result.getAmount() / 365.25;
    return Collections.singleton(new ComputedValue(spec, thetaValue));
  }
}


text:
.loading {
  position: relative;
  height: 100%;
}

.loading:before {
  position: absolute;
  content: " ";
  left:0;
  right:0;
  bottom:0;
  top:0;
  z-index: 1000;
  background:rgba(255,255,255,0.9) no-repeat center center;
  background-image: url('loading-animation.gif');
}

.animate-view.ng-enter,
.animate-view.ng-leave {
  transition: 1s linear all;
}

.animate-view.ng-enter {
  opacity: 0;
}
.animate-view.ng-enter.ng-enter-active {
  opacity: 1;
}

.animate-view.ng-leave{
  opacity: 1;
}

.animate-view.ng-leave.ng-leave-active {
  opacity: 0;
}


text:
FOUNDATION_EXPORT double YHKitVersionNumber;

//! Project version string for YHKit.
FOUNDATION_EXPORT const unsigned char YHKitVersionString[];

// In this header, you should import all the public headers of your framework using statements like #import <YHKit/PublicHeader.h>


text:
.demo__group {
    position: relative; vertical-align: top;
}
    .demo {
        display: inline-block; width: 50%;
    }


text:
mod bar {
    pub trait QueryId {
        const SOME_PROPERTY: bool;
    }
}

use bar::QueryId;

#[allow(non_camel_case_types)]
pub struct bool;

impl QueryId for bool {
    const SOME_PROPERTY: core::primitive::bool = true;
}

fn main() {}


text:
package com.example.tests;

import com.example.fw.ApplicationManager;
import com.example.fw.JdbcHelper;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

/**
 * Created by nataliamaslova on 9/19/2014.
 */
public class SampleWithDBHibernate {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.load(new FileReader(new File("application.properties")));
        ApplicationManager app = new ApplicationManager(properties);
        System.out.println(app.getHibernateHelper().listGroups());
    }
}


text:
package com.opengamma.analytics.math.curve;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.Validate;

import com.opengamma.analytics.math.ParallelArrayBinarySort;
import com.opengamma.util.tuple.Pair;

/**
/**
 * Parent class for a family of curves that can have any time of data on the x and y axes, provided that the x data is {@link Comparable}.
 * It is possible to construct a curve using either unsorted (in x) data or sorted (ascending in x). Note that if the constructor
 * is told that unsorted data are sorted then no sorting will take place, which will give unpredictable results.
 * @param <T> The type of the x data
 * @param  The type of the y data
 */
public abstract class ObjectsCurve<T extends Comparable<T>, U> extends Curve<T, U> {
  private final int _n;
  private final T[] _xData;
  private final U[] _yData;

  /**
   *
   * @param xData An array of x data, not null
   * @param yData An array of y data, not null, contains same number of entries as x
   * @param isSorted Is the x-data sorted
   */
  public ObjectsCurve(final T[] xData, final U[] yData, final boolean isSorted) {
    super();
    Validate.notNull(xData, "x data");
    Validate.notNull(yData, "y data");
    _n = xData.length;
    Validate.isTrue(_n == yData.length);
    _xData = Arrays.copyOf(xData, _n);
    _yData = Arrays.copyOf(yData, _n);
    for (int i = 0; i < _n; i++) {
      Validate.notNull(xData[i], "element " + i + " of x data");
      Validate.notNull(yData[i], "element " + i + " of y data");
    }
    if (!isSorted) {
      ParallelArrayBinarySort.parallelBinarySort(_xData, _yData);
    }
  }

  /**
   *
   * @param data A map of x-y data, not null
   * @param isSorted Is the x-data sorted
   */
  public ObjectsCurve(final Map<T, U> data, final boolean isSorted) {
    super();
    Validate.notNull(data, "data");
    Validate.noNullElements(data.keySet(), "x values");
    Validate.noNullElements(data.values(), "y values");
    _n = data.size();
    final Map.Entry<T, U> firstEntry = data.entrySet().iterator().next();
    _xData = data.keySet().toArray((T[]) Array.newInstance(firstEntry.getKey().getClass(), 0));
    _yData = data.values().toArray((U[]) Array.newInstance(firstEntry.getValue().getClass(), 0));
    if (!isSorted) {
      ParallelArrayBinarySort.parallelBinarySort(_xData, _yData);
    }
  }

  /**
   *
   * @param data A set of x-y pairs, not null
   * @param isSorted Is the x-data sorted
   */
  public ObjectsCurve(final Set<Pair<T, U>> data, final boolean isSorted) {
    super();
    Validate.notNull(data, "data");
    _n = data.size();
    final List<T> xTemp = new ArrayList<T>(_n);
    final List yTemp = new ArrayList(_n);
    for (final Pair<T, U> entry : data) {
      Validate.notNull(entry, "element of data");
      xTemp.add(entry.getFirst());
      yTemp.add(entry.getSecond());
    }
    final Pair<T, U> firstEntry = data.iterator().next();
    _xData = xTemp.toArray((T[]) Array.newInstance(firstEntry.getKey().getClass(), 0));
    _yData = yTemp.toArray((U[]) Array.newInstance(firstEntry.getValue().getClass(), 0));
    if (!isSorted) {
      ParallelArrayBinarySort.parallelBinarySort(_xData, _yData);
    }
  }

  /**
   *
   * @param xData A list of x data points, assumed to be sorted ascending, not null
   * @param yData A list of y data points, not null, contains same number of entries as x
   * @param isSorted Is the x-data sorted
   */
  public ObjectsCurve(final List<T> xData, final List yData, final boolean isSorted) {
    super();
    Validate.notNull(xData, "x data");
    Validate.notNull(yData, "y data");
    _n = xData.size();
    Validate.isTrue(_n == yData.size());
    _xData = xData.toArray((T[]) Array.newInstance(xData.get(0).getClass(), 0));
    _yData = yData.toArray((U[]) Array.newInstance(yData.get(0).getClass(), 0));
    if (!isSorted) {
      ParallelArrayBinarySort.parallelBinarySort(_xData, _yData);
    }
  }

  /**
   *
   * @param xData An array of x data, not null
   * @param yData An array of y data, not null, contains same number of entries as x
   * @param isSorted Is the x-data sorted
   * @param name The name of the curve
   */
  public ObjectsCurve(final T[] xData, final U[] yData, final boolean isSorted, final String name) {
    super(name);
    Validate.notNull(xData, "x data");
    _n = xData.length;
    Validate.notNull(yData, "y data");
    Validate.isTrue(_n == yData.length);
    _xData = Arrays.copyOf(xData, _n);
    _yData = Arrays.copyOf(yData, _n);
    if (!isSorted) {
      ParallelArrayBinarySort.parallelBinarySort(_xData, _yData);
    }
  }

  /**
   *
   * @param data A map of x-y data, not null
   * @param isSorted Is the x-data sorted
   * @param name The name of the curve
   */
  public ObjectsCurve(final Map<T, U> data, final boolean isSorted, final String name) {
    super(name);
    Validate.notNull(data, "data");
    Validate.noNullElements(data.keySet(), "x values");
    Validate.noNullElements(data.values(), "y values");
    _n = data.size();
    final Map.Entry<T, U> firstEntry = data.entrySet().iterator().next();
    _xData = data.keySet().toArray((T[]) Array.newInstance(firstEntry.getKey().getClass(), 0));
    _yData = data.values().toArray((U[]) Array.newInstance(firstEntry.getValue().getClass(), 0));
    if (!isSorted) {
      ParallelArrayBinarySort.parallelBinarySort(_xData, _yData);
    }

  }

  /**
   *
   * @param data A set of x-y pairs, not null
   * @param isSorted Is the x-data sorted
   * @param name The name of the curve
   */
  public ObjectsCurve(final Set<Pair<T, U>> data, final boolean isSorted, final String name) {
    super(name);
    Validate.notNull(data, "data");
    _n = data.size();
    final List<T> xTemp = new ArrayList<T>(_n);
    final List yTemp = new ArrayList(_n);
    final int i = 0;
    for (final Pair<T, U> entry : data) {
      Validate.notNull(entry, "element " + i + " of data");
      xTemp.add(entry.getFirst());
      yTemp.add(entry.getSecond());
    }
    final Pair<T, U> firstEntry = data.iterator().next();
    _xData = xTemp.toArray((T[]) Array.newInstance(firstEntry.getKey().getClass(), 0));
    _yData = yTemp.toArray((U[]) Array.newInstance(firstEntry.getValue().getClass(), 0));
    if (!isSorted) {
      ParallelArrayBinarySort.parallelBinarySort(_xData, _yData);
    }
  }

  /**
   *
   * @param xData A list of x data, not null
   * @param yData A list of y data, not null, contains same number of entries as x
   * @param isSorted Is the x-data sorted
   * @param name The name of the curve
   */
  public ObjectsCurve(final List<T> xData, final List yData, final boolean isSorted, final String name) {
    super(name);
    Validate.notNull(xData, "x data");
    Validate.notNull(yData, "y data");
    _n = xData.size();
    Validate.isTrue(_n == yData.size());
    _xData = xData.toArray((T[]) Array.newInstance(xData.get(0).getClass(), 0));
    _yData = yData.toArray((U[]) Array.newInstance(yData.get(0).getClass(), 0));
    if (!isSorted) {
      ParallelArrayBinarySort.parallelBinarySort(_xData, _yData);
    }
  }

  @Override
  public T[] getXData() {
    return _xData;
  }

  @Override
  public U[] getYData() {
    return _yData;
  }

  @Override
  public int size() {
    return _n;
  }

  @Override
  public int hashCode() {
    final int prime = 31;
    int result = super.hashCode();
    result = prime * result + Arrays.hashCode(_xData);
    result = prime * result + Arrays.hashCode(_yData);
    return result;
  }

  @Override
  public boolean equals(final Object obj) {
    if (this == obj) {
      return true;
    }
    if (!super.equals(obj)) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final ObjectsCurve<?, ?> other = (ObjectsCurve<?, ?>) obj;
    return ArrayUtils.isEquals(_xData, other._xData) && ArrayUtils.isEquals(_yData, other._yData);
  }

}


text:
package org.matrix.androidsdk.crypto.data;

import com.google.gson.JsonElement;

import org.matrix.androidsdk.core.callback.ApiCallback;

public class MXQueuedEncryption {

    /**
     * The data to encrypt.
     */
    public JsonElement mEventContent;
    public String mEventType;

    /**
     * the asynchronous callback
     */
    public ApiCallback<JsonElement> mApiCallback;
}


text:
package com.sksamuel.elastic4s.http.search.queries

import com.sksamuel.elastic4s.http.search.queries.nested.HasChildBodyFn
import com.sksamuel.elastic4s.searches.ScoreMode
import com.sksamuel.elastic4s.searches.queries.{HasChildQuery, InnerHit}
import com.sksamuel.elastic4s.searches.queries.matches.MatchQuery
import org.scalatest.{FunSuite, Matchers}

class HasChildBodyFnTest extends FunSuite with Matchers {

  test("has child should generate expected json") {
    val q = HasChildQuery("blog_tag", MatchQuery("tag", "something"), ScoreMode.Min)
      .boost(1.2)
      .minMaxChildren(2, 10)
      .ignoreUnmapped(true)
      .queryName("myquery")
      .innerHit(InnerHit("inners"))
    HasChildBodyFn(q).string() shouldBe
      """{"has_child":{"type":"blog_tag","min_children":2,"max_children":10,"score_mode":"min","query":{"match":{"tag":{"query":"something"}}},"ignore_unmapped":true,"boost":1.2,"_name":"myquery","inner_hits":{"name":"inners"}}}"""
  }
}


text:
<?xml version="1.0" ?>
<container xmlns="http://symfony.com/schema/dic/services"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
    <services>

        <!-- Services -->
        <service id="dsn_recommendation.recommendation"
            class="DsnRecommendation\Components\Neo\Recommendation">

            <argument type="service" id="dsn_recommendation.neo_client" />

        </service>
        <service id="dsn_recommendation.sync_service"
            class="DsnRecommendation\Components\Neo\SyncOrder">

            <argument type="service" id="dsn_recommendation.neo_client" />
        </service>
        <service id="dsn_recommendation.demo"
            class="DsnRecommendation\Components\DemoData\DemoData">

            <argument type="service" id="dsn_recommendation.demo.items" />
            <argument type="service" id="dsn_recommendation.demo.customer" />
            <argument type="service" id="dsn_recommendation.demo.order" />
        </service>

        <service id="dsn_recommendation.bulk_exporter"
                 class="DsnRecommendation\Components\Neo\BulkExporter">

            <argument type="service" id="dsn_recommendation.neo_client" />
            <argument type="service" id="dsn_recommendation.csv_export" />
        </service>

        <service id="dsn_recommendation.csv_export"
                 class="DsnRecommendation\Components\CsvExporter">

            <argument type="service" id="dbal_connection" />
        </service>

        <service id="dsn_recommendation.demo.items"
                 class="DsnRecommendation\Components\DemoData\Items">

            <argument type="service" id="dsn_recommendation.article_api" />
        </service>
        <service id="dsn_recommendation.demo.customer"
                 class="DsnRecommendation\Components\DemoData\Customer">

            <argument type="service" id="dsn_recommendation.customer_api" />
        </service>
        <service id="dsn_recommendation.demo.order"
                 class="DsnRecommendation\Components\DemoData\Order">
        </service>

        <service id="api_factory" class="Shopware\Components\Api\Manager" />
        <service id="dsn_recommendation.customer_api" class="Shopware\Components\Api\Resource\Customer">
            <factory service="api_factory" method="getResource" />
            <argument>customer</argument>
        </service>
        <service id="dsn_recommendation.article_api" class="Shopware\Components\Api\Resource\Article">
            <factory service="api_factory" method="getResource" />
            <argument>article</argument>
        </service>

        <service id="dsn_recommendation.neo_client_factory"
                class="DsnRecommendation\Components\Neo\ClientFactory">
        </service>
        <service id="dsn_recommendation.neo_client" class="Everyman\Neo4j\Client">
                <factory service="dsn_recommendation.neo_client_factory" method="factory"/>
        </service>

        <!-- Commands -->
        <service id="dsn_recommendation.commands.recommendation"
                 class="DsnRecommendation\Commands\Recommendation">
            <tag name="console.command" />

        </service>
        <service id="dsn_recommendation.commands.recommendation_deomo_data"
                 class="DsnRecommendation\Commands\RecommendationDemoData">
            <tag name="console.command" />

        </service>

        <!-- Subscriber -->
        <service id="dsn_recommendation.subscriber.order"
                 class="DsnRecommendation\Subscriber\Order">
            <tag name="shopware.event_subscriber" />

        </service>
        <service id="dsn_recommendation.subscriber.recommendation"
                 class="DsnRecommendation\Subscriber\Recommendation">
            <tag name="shopware.event_subscriber" />

        </service>

    </services>
</container>


text:
package nz.org.nesi.goji.view.cli;

import java.util.List;

import com.beust.jcommander.Parameter;
import com.google.common.collect.Lists;

public class GojiLsParameters {

	@Parameter(description = "urls/paths to list")
	private List<String> urls = Lists.newArrayList();;

	public List<String> getUrls() {
		return urls;
	}

}


text:
typedef struct af_move_t {
    int id;
    animation ani;
    uint8_t pos_constraints;
    uint8_t next_move;
    uint8_t successor_id;
    uint8_t category;
    uint16_t points;
    uint8_t scrap_amount;
    uint8_t collision_opts;
    float damage;
    str move_string;
    str footer_string;
#ifdef DEBUGMODE
    char unknown[21];
#endif
} af_move;

void af_move_create(af_move *move, void *src, int id);
void af_move_free(af_move *move);

#endif // AF_MOVE_H


text:
import xml.sax
import rdflib

from django.db import transaction

from hs_core.serialization import GenericResourceMeta

class RasterResourceMeta(GenericResourceMeta):
    """
    Lightweight class for representing metadata of RasterResource instances.
    """
    def __init__(self):
        super(RasterResourceMeta, self).__init__()

        self.cell_info = None
        self.band_info = []
        self.spatial_reference = None

    def _read_resource_metadata(self):
        super(RasterResourceMeta, self)._read_resource_metadata()

        print("--- RasterResourceMeta ---")

        # Also parse using SAX so that we can capture certain metadata elements
        # in the same order in which they appear in the RDF+XML serialization.
        SAX_parse_results = RasterResourceSAXHandler()
        xml.sax.parse(self.rmeta_path, SAX_parse_results)

        hsterms = rdflib.namespace.Namespace('http://hydroshare.org/terms/')

        # Get CellInformation
        for s, p, o in self._rmeta_graph.triples((None, hsterms.CellInformation, None)):
            self.cell_info = RasterResourceMeta.CellInformation()
            # Get name
            name_lit = self._rmeta_graph.value(o, hsterms.name)
            if name_lit is None:
                msg = "Name for CellInformation was not found for resource {0}".\
                    format(self.root_uri)
                raise GenericResourceMeta.ResourceMetaException(msg)
            self.cell_info.name = str(name_lit)
            # Get rows
            rows_lit = self._rmeta_graph.value(o, hsterms.rows)
            if rows_lit is None:
                msg = "Rows attribute was not found for CellInformation for resource {0}".\
                    format(self.root_uri)
                raise GenericResourceMeta.ResourceMetaException(msg)
            self.cell_info.rows = int(str(rows_lit))
            # Get columns
            columns_lit = self._rmeta_graph.value(o, hsterms.columns)
            if columns_lit is None:
                msg = "Columns attribute was not found for CellInformation for resource {0}".\
                    format(self.root_uri)
                raise GenericResourceMeta.ResourceMetaException(msg)
            self.cell_info.columns = int(str(columns_lit))
            # Get cellSizeXValue
            cellX_lit = self._rmeta_graph.value(o, hsterms.cellSizeXValue)
            if cellX_lit is None:
                msg = "cellSizeXValue attribute was not found for CellInformation "
                msg += "for resource {0}"
                msg = msg.format(self.root_uri)
                raise GenericResourceMeta.ResourceMetaException(msg)
            self.cell_info.cellSizeXValue = float(str(cellX_lit))
            # Get cellSizeYValue
            cellY_lit = self._rmeta_graph.value(o, hsterms.cellSizeYValue)
            if cellY_lit is None:
                msg = "cellSizeYValue attribute was not found for CellInformation "
                msg += "for resource {0}"
                msg = msg.format(self.root_uri)
                raise GenericResourceMeta.ResourceMetaException(msg)
            self.cell_info.cellSizeYValue = float(str(cellY_lit))
            # Get cellDataType
            celldt_lit = self._rmeta_graph.value(o, hsterms.cellDataType)
            if celldt_lit is None:
                msg = "cellDataType attribute was not found for CellInformation "
                msg += "for resource {0}"
                msg = msg.format(self.root_uri)
                raise GenericResourceMeta.ResourceMetaException(msg)
            self.cell_info.cellDataType = str(celldt_lit)
            # Get noDateValue
            nodata_lit = self._rmeta_graph.value(o, hsterms.noDataValue)
            if nodata_lit is not None:
                self.cell_info.noDataValue = float(str(nodata_lit))
            print("\t\t{0}".format(self.cell_info))

        # Get BandInformation
        if SAX_parse_results:
            # Use band info from SAX parser
            self.band_info = list(SAX_parse_results.band_info)
        else:
            # Get band info from RDF
            for s, p, o in self._rmeta_graph.triples((None, hsterms.BandInformation, None)):
                band_info = RasterResourceMeta.BandInformation()
                # Get name
                name_lit = self._rmeta_graph.value(o, hsterms.name)
                if name_lit is None:
                    msg = "Name for BandInformation was not found for resource {0}".\
                        format(self.root_uri)
                    raise GenericResourceMeta.ResourceMetaException(msg)
                band_info.name = str(name_lit)
                # Get variableName
                varname_lit = self._rmeta_graph.value(o, hsterms.variableName)
                if varname_lit is None:
                    msg = "variableName for BandInformation was not found for resource {0}".\
                        format(self.root_uri)
                    raise GenericResourceMeta.ResourceMetaException(msg)
                band_info.variableName = str(varname_lit)
                # Get variableUnit
                varunit_lit = self._rmeta_graph.value(o, hsterms.variableUnit)
                if varunit_lit is None:
                    msg = "variableUnit for BandInformation was not found for resource {0}".\
                        format(self.root_uri)
                    raise GenericResourceMeta.ResourceMetaException(msg)
                band_info.variableUnit = str(varunit_lit)
                # Get method
                method_lit = self._rmeta_graph.value(o, hsterms.method)
                if method_lit is not None:
                    band_info.method = str(method_lit)
                # Get comment
                comment_lit = self._rmeta_graph.value(o, hsterms.comment)
                if comment_lit is not None:
                    band_info.comment = str(comment_lit)
                self.band_info.append(band_info)
        for b in self.band_info:
            print("\t\t{0}".format(str(b)))

        # Get spatialReference
        for s, p, o in self._rmeta_graph.triples((None, hsterms.spatialReference, None)):
            spat_ref_lit = self._rmeta_graph.value(o, rdflib.namespace.RDF.value)
            if spat_ref_lit is None:
                msg = "Spatial reference value not found for {0}.".format(o)
                raise GenericResourceMeta.ResourceMetaException(msg)
            self.spatial_reference = RasterResourceMeta.SpatialReference(str(spat_ref_lit))
            print("\t\t{0}".format(self.spatial_reference))

    @transaction.atomic
    def write_metadata_to_resource(self, resource):
        """
        Write metadata to resource

        :param resource: RasterResource instance
        """
        super(RasterResourceMeta, self).write_metadata_to_resource(resource)

        if self.cell_info:
            resource.metadata.cellInformation.delete()
            resource.metadata.create_element('CellInformation', name=self.cell_info.name,
                                             rows=self.cell_info.rows,
                                             columns=self.cell_info.columns,
                                             cellSizeXValue=self.cell_info.cellSizeXValue,
                                             cellSizeYValue=self.cell_info.cellSizeYValue,
                                             cellDataType=self.cell_info.cellDataType,
                                             noDataValue=self.cell_info.noDataValue)
        if len(self.band_info) > 0:
            for band in resource.metadata.bandInformation:
                band.delete()
            for b in self.band_info:
                resource.metadata.create_element('BandInformation', name=b.name,
                                                 variableName=b.variableName,
                                                 variableUnit=b.variableUnit, method=b.method,
                                                 comment=b.comment)
        if self.spatial_reference:
            resource.metadata.originalCoverage.delete()
            values = {'units': self.spatial_reference.units,
                      'northlimit': self.spatial_reference.northlimit,
                      'eastlimit': self.spatial_reference.eastlimit,
                      'southlimit': self.spatial_reference.southlimit,
                      'westlimit': self.spatial_reference.westlimit,
                      'projection': self.spatial_reference.projection}
            kwargs = {'value': values}
            resource.metadata.create_element('OriginalCoverage', **kwargs)

    class CellInformation(object):

        def __init__(self):
            self.name = None
            self.rows = None
            self.columns = None
            self.cellSizeXValue = None
            self.cellSizeYValue = None
            self.cellDataType = None
            self.noDataValue = None  # Optional

        def __str__(self):
            msg = "CellInformation name: {name}, "
            msg += "rows: {rows}, columns: {columns}, "
            msg += "cellSizeXValue: {cellSizeXValue}, cellSizeYValue: {cellSizeYValue}, "
            msg += "cellDataType: {cellDataType}, noDataValue: {noDataValue}"
            msg = msg.format(name=self.name, rows=self.rows,
                             columns=self.columns, cellSizeXValue=self.cellSizeXValue,
                             cellSizeYValue=self.cellSizeYValue, cellDataType=self.cellDataType,
                             noDataValue=self.noDataValue)
            return msg

        def __unicode__(self):
            return unicode(str(self))

    class BandInformation(object):

        def __init__(self):
            self.name = None
            self.variableName = None
            self.variableUnit = None
            self.method = None  # Optional
            self.comment = None  # Optional

        def __str__(self):
            msg = "BandInformation name: {name}, "
            msg += "variableName: {variableName}, variableUnit: {variableUnit}, "
            msg += "method: {method}, comment: {comment}"
            msg = msg.format(name=self.name, variableName=self.variableName,
                             variableUnit=self.variableUnit, method=self.method,
                             comment=self.comment)
            return msg

        def __unicode__(self):
            return unicode(str(self))

    class SpatialReference(object):

        def __init__(self):
            self.northlimit = None
            self.eastlimit = None
            self.southlimit = None
            self.westlimit = None
            self.units = None
            self.projection = None  # Optional

        def __str__(self):
            msg = "SpatialReference northlimit: {northlimit}, "
            msg += "eastlimit: {eastlimit}, southlimit: {southlimit}, "
            msg += "westlimit: {westlimit}, units: {units}, projection: {projection}"
            msg = msg.format(northlimit=self.northlimit, eastlimit=self.eastlimit,
                             southlimit=self.southlimit, westlimit=self.westlimit,
                             units=self.units, projection=self.projection)
            return msg

        def __unicode__(self):
            return unicode(str(self))

        def __init__(self, value_str):
            kvp = value_str.split(';')
            for pair in kvp:
                (key, value) = pair.split('=')
                key = key.strip()
                value = value.strip()
                if key == 'name':
                    self.name = value
                elif key == 'eastlimit':
                    try:
                        self.eastlimit = float(value)
                    except Exception as e:
                        msg = "Unable to parse east limit {0}, error: {1}".format(value,
                                                                                str(e))
                        raise GenericResourceMeta.ResourceMetaException(msg)
                elif key == 'northlimit':
                    try:
                        self.northlimit = float(value)
                    except Exception as e:
                        msg = "Unable to parse north limit {0}, error: {1}".format(value,
                                                                                str(e))
                        raise GenericResourceMeta.ResourceMetaException(msg)
                elif key == 'southlimit':
                    try:
                        self.southlimit = float(value)
                    except Exception as e:
                        msg = "Unable to parse south limit {0}, error: {1}".format(value,
                                                                                str(e))
                        raise GenericResourceMeta.ResourceMetaException(msg)
                elif key == 'westlimit':
                    try:
                        self.westlimit = float(value)
                    except Exception as e:
                        msg = "Unable to parse west limit {0}, error: {1}".format(value,
                                                                                str(e))
                        raise GenericResourceMeta.ResourceMetaException(msg)
                elif key == 'units':
                    self.units = value
                elif key == 'projection':
                    self.projection = value

class RasterResourceSAXHandler(xml.sax.ContentHandler):
    def __init__(self):
        xml.sax.ContentHandler.__init__(self)

        # Content
        self.band_info = []

        # State variables
        self._get_bandinfo = False
        self._get_bandinfo_details = False
        self._get_bandinfo_name = False
        self._bandinfo_name = None
        self._get_bandinfo_var_name = False
        self._bandinfo_var_name = None
        self._get_bandinfo_var_unit = False
        self._bandinfo_var_unit = None
        self._get_bandinfo_method = False
        self._bandinfo_method = None
        self._get_bandinfo_comment = False
        self._bandinfo_comment = None

    def characters(self, content):
        if self._get_bandinfo_name:
            if len(self.band_info) < 1:
                msg = "Error: haven't yet encountered band information, "
                msg += "yet trying to store band information name."
                raise xml.sax.SAXException(msg)
            self._bandinfo_name.append(content)

        elif self._get_bandinfo_var_name:
            if len(self.band_info) < 1:
                msg = "Error: haven't yet encountered band information, "
                msg += "yet trying to store band information variable name."
                raise xml.sax.SAXException(msg)
            self._bandinfo_var_name.append(content)

        elif self._get_bandinfo_var_unit:
            if len(self.band_info) < 1:
                msg = "Error: haven't yet encountered band information, "
                msg += "yet trying to store band information variable unit."
                raise xml.sax.SAXException(msg)
            self._bandinfo_var_unit.append(content)

        elif self._get_bandinfo_method:
            if len(self.band_info) < 1:
                msg = "Error: haven't yet encountered band information, "
                msg += "yet trying to store band information method."
                raise xml.sax.SAXException(msg)
            self._bandinfo_method.append(content)

        elif self._get_bandinfo_comment:
            if len(self.band_info) < 1:
                msg = "Error: haven't yet encountered band information, "
                msg += "yet trying to store band information comment."
                raise xml.sax.SAXException(msg)
            self._bandinfo_comment.append(content)

    def startElement(self, name, attrs):
        if name == 'hsterms:BandInformation':
            if self._get_bandinfo:
                raise xml.sax.SAXException("Error: nested hsterms:BandInformation elements.")
            self._get_bandinfo = True

        elif name == 'rdf:Description':
            if self._get_bandinfo:
                if self._get_bandinfo_details:
                    msg = "Error: nested rdf:Description elements " \
                          "within hsterms:BandInformation element."
                    raise xml.sax.SAXException(msg)
                # Create new band info
                self.band_info.append(RasterResourceMeta.BandInformation())
                self._get_bandinfo_details = True

        elif name == 'hsterms:name':
            if self._get_bandinfo_details:
                if self._get_bandinfo_name:
                    raise xml.sax.SAXException("Error: nested hsterms:name elements "
                                               "within hsterms:BandInformation.")
                self._get_bandinfo_name = True
                self._bandinfo_name = []

        elif name == 'hsterms:variableName':
            if self._get_bandinfo_details:
                if self._get_bandinfo_var_name:
                    raise xml.sax.SAXException("Error: nested hsterms:variableName elements "
                                               "within hsterms:BandInformation.")
                self._get_bandinfo_var_name = True
                self._bandinfo_var_name = []

        elif name == 'hsterms:variableUnit':
            if self._get_bandinfo_details:
                if self._get_bandinfo_var_unit:
                    raise xml.sax.SAXException("Error: nested hsterms:variableUnit elements "
                                               "within hsterms:BandInformation.")
                self._get_bandinfo_var_unit = True
                self._bandinfo_var_unit = []

        elif name == 'hsterms:method':
            if self._get_bandinfo_details:
                if self._get_bandinfo_method:
                    raise xml.sax.SAXException("Error: nested hsterms:method elements "
                                               "within hsterms:BandInformation.")
                self._get_bandinfo_method = True
                self._bandinfo_method = []

        elif name == 'hsterms:comment':
            if self._get_bandinfo_details:
                if self._get_bandinfo_comment:
                    raise xml.sax.SAXException("Error: nested hsterms:comment elements "
                                               "within hsterms:BandInformation.")
                self._get_bandinfo_comment = True
                self._bandinfo_comment = []

    def endElement(self, name):
        if name == 'hsterms:BandInformation':
            if not self._get_bandinfo:
                msg = "Error: close hsterms:BandInformation tag without corresponding open tag."
                raise xml.sax.SAXException(msg)
            self._get_bandinfo = False

        elif name == 'rdf:Description':
            if self._get_bandinfo:
                if not self._get_bandinfo_details:
                    msg = "Error: close rdf:Description tag without corresponding open tag "
                    msg += "within hsterms:BandInformation."
                    raise xml.sax.SAXException(msg)
                self._get_bandinfo_details = False

        elif name == 'hsterms:name':
            if self._get_bandinfo_details:
                if not self._get_bandinfo_name:
                    msg = "Error: close hsterms:name tag without corresponding open tag "
                    msg += "within hsterms:BandInformation."
                    raise xml.sax.SAXException(msg)
                self.band_info[-1].name = "".join(self._bandinfo_name)
                self._bandinfo_name = None
                self._get_bandinfo_name = False

        elif name == 'hsterms:variableName':
            if self._get_bandinfo_details:
                if not self._get_bandinfo_var_name:
                    msg = "Error: close hsterms:variableName tag without corresponding open tag "
                    msg += "within hsterms:BandInformation."
                    raise xml.sax.SAXException(msg)
                self.band_info[-1].variableName = "".join(self._bandinfo_var_name)
                self._bandinfo_var_name = None
                self._get_bandinfo_var_name = False

        elif name == 'hsterms:variableUnit':
            if self._get_bandinfo_details:
                if not self._get_bandinfo_var_unit:
                    msg = "Error: close hsterms:variableUnit tag without corresponding open tag "
                    msg += "within hsterms:BandInformation."
                    raise xml.sax.SAXException(msg)
                self.band_info[-1].variableUnit = "".join(self._bandinfo_var_unit)
                self._bandinfo_var_unit = None
                self._get_bandinfo_var_unit = False

        elif name == 'hsterms:method':
            if self._get_bandinfo_details:
                if not self._get_bandinfo_method:
                    msg = "Error: close hsterms:method tag without corresponding open tag "
                    msg += "within hsterms:BandInformation."
                    raise xml.sax.SAXException(msg)
                self.band_info[-1].method = "".join(self._bandinfo_method)
                self._bandinfo_method = None
                self._get_bandinfo_method = False

        elif name == 'hsterms:comment':
            if self._get_bandinfo_details:
                if not self._get_bandinfo_comment:
                    msg = "Error: close hsterms:comment tag without corresponding open tag "
                    msg += "within hsterms:BandInformation."
                    raise xml.sax.SAXException(msg)
                self.band_info[-1].comment = "".join(self._bandinfo_comment)
                self._bandinfo_comment = None
                self._get_bandinfo_comment = False


text:
@class ComGoogleCommonCollectImmutableCollection;
@class ComGoogleCommonCollectImmutableList;
@class ComGoogleCommonCollectImmutableSet;
@class ComGoogleCommonCollectImmutableSortedSet;
@class ComGoogleCommonCollectRegularImmutableSortedSet;

#define ComGoogleCommonCollectImmutableSortedMap_RESTRICT 1
#define ComGoogleCommonCollectImmutableSortedMap_INCLUDE 1
#include "com/google/common/collect/ImmutableSortedMap.h"

@interface ComGoogleCommonCollectRegularImmutableSortedMap : ComGoogleCommonCollectImmutableSortedMap {
}

- (instancetype)initWithComGoogleCommonCollectRegularImmutableSortedSet:(ComGoogleCommonCollectRegularImmutableSortedSet *)keySet
                                withComGoogleCommonCollectImmutableList:(ComGoogleCommonCollectImmutableList *)valueList;

- (instancetype)initWithComGoogleCommonCollectRegularImmutableSortedSet:(ComGoogleCommonCollectRegularImmutableSortedSet *)keySet
                                withComGoogleCommonCollectImmutableList:(ComGoogleCommonCollectImmutableList *)valueList
                           withComGoogleCommonCollectImmutableSortedMap:(ComGoogleCommonCollectImmutableSortedMap *)descendingMap;

- (ComGoogleCommonCollectImmutableSet *)createEntrySet;

- (ComGoogleCommonCollectImmutableSortedSet *)keySet;

- (ComGoogleCommonCollectImmutableCollection *)values;

- (id)getWithId:(id)key;

- (ComGoogleCommonCollectImmutableSortedMap *)headMapWithId:(id)toKey
                                                withBoolean:(jboolean)inclusive;

- (ComGoogleCommonCollectImmutableSortedMap *)tailMapWithId:(id)fromKey
                                                withBoolean:(jboolean)inclusive;

- (ComGoogleCommonCollectImmutableSortedMap *)createDescendingMap;

@end

J2OBJC_EMPTY_STATIC_INIT(ComGoogleCommonCollectRegularImmutableSortedMap)

CF_EXTERN_C_BEGIN
CF_EXTERN_C_END
#endif

J2OBJC_TYPE_LITERAL_HEADER(ComGoogleCommonCollectRegularImmutableSortedMap)
#if !defined (_ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet_) && (ComGoogleCommonCollectRegularImmutableSortedMap_INCLUDE_ALL || ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet_INCLUDE)
#define _ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet_

@class ComGoogleCommonCollectImmutableList;
@class ComGoogleCommonCollectImmutableMap;
@class ComGoogleCommonCollectRegularImmutableSortedMap;
@class ComGoogleCommonCollectUnmodifiableIterator;

#define ComGoogleCommonCollectImmutableMapEntrySet_RESTRICT 1
#define ComGoogleCommonCollectImmutableMapEntrySet_INCLUDE 1
#include "com/google/common/collect/ImmutableMapEntrySet.h"

@interface ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet : ComGoogleCommonCollectImmutableMapEntrySet {
}

- (ComGoogleCommonCollectUnmodifiableIterator *)iterator;

- (ComGoogleCommonCollectImmutableList *)createAsList;

- (ComGoogleCommonCollectImmutableMap *)map;

- (instancetype)initWithComGoogleCommonCollectRegularImmutableSortedMap:(ComGoogleCommonCollectRegularImmutableSortedMap *)outer$;

@end

J2OBJC_EMPTY_STATIC_INIT(ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet)

CF_EXTERN_C_BEGIN
CF_EXTERN_C_END
#endif

J2OBJC_TYPE_LITERAL_HEADER(ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet)
#if !defined (_ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet_$1_) && (ComGoogleCommonCollectRegularImmutableSortedMap_INCLUDE_ALL || ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet_$1_INCLUDE)
#define _ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet_$1_

@class ComGoogleCommonCollectImmutableCollection;
@class ComGoogleCommonCollectImmutableList;
@class ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet;
@protocol JavaUtilMap_Entry;

#define ComGoogleCommonCollectImmutableAsList_RESTRICT 1
#define ComGoogleCommonCollectImmutableAsList_INCLUDE 1
#include "com/google/common/collect/ImmutableAsList.h"

@interface ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet_$1 : ComGoogleCommonCollectImmutableAsList {
}

- (id<JavaUtilMap_Entry>)getWithInt:(jint)index;

- (ComGoogleCommonCollectImmutableCollection *)delegateCollection;

- (instancetype)initWithComGoogleCommonCollectRegularImmutableSortedMap_EntrySet:(ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet *)outer$;

@end

J2OBJC_EMPTY_STATIC_INIT(ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet_$1)

CF_EXTERN_C_BEGIN
CF_EXTERN_C_END
#endif

J2OBJC_TYPE_LITERAL_HEADER(ComGoogleCommonCollectRegularImmutableSortedMap_EntrySet_$1)


text:
set CC=gcc
set CXX=g++
set F77=gfortran
set F90=gfortran

mingw32-make -j%CPU_COUNT%
mingw32-make QM

%PYTHON% setup.py install

:: Save version number stored in rmgpy/__init__.py file
%PYTHON% -c "from rmgpy import __version__; print __version__" > %SRC_DIR%\__conda_version__.txt

:: lazy "install" of everything in our 'external' folder.
:: most of which should probably be elsewhere
mkdir %SP_DIR%\external
xcopy %SRC_DIR%\external %SP_DIR%\external /E /Y


text:
<?php

namespace App\Models;

use App\Shared\Database\MinnichSAP;
use App\Shared\Database\MinnichSite;
use App\Shared\Models\ESM;
use App\Shared\Models\MinnichModels;
use CodeIgniter\HTTP\Files\UploadedFile;

class ShopModel extends MinnichModels {
	public function __construct() { }

	public function get($post) {
		return parent::get( $post ); // TODO: Change the autogenerated stub
	}

	public function save($post) {
		return parent::save( $post ); // TODO: Change the autogenerated stub
	}

	public function delete($post) {
		return parent::delete( $post ); // TODO: Change the autogenerated stub
	}

	public function upload($post, UploadedFile $file) {
		return parent::upload( $post, $file ); // TODO: Change the autogenerated stub
	}

	public function getPart($part) {
		$part = preg_replace( '/[^-0-9\.a-zA-Z]+/', '', $part );

		$select = implode( ', ', [
			"o1.*",
			"CAST(o2.Price as nvarchar(100)) As Price",
		] );

		$join  = "INNER JOIN ITM1 o2 on o1.ItemCode = o2.ItemCode";
		$where = implode( ' AND ', [
			"o2.pricelist = 1",
			"o1.frozenfor = 'N'",
			"o1.ItemCode = '$part'",
		] );
		$data  = MinnichSAP::R()->getRow( "SELECT $select FROM OITM o1 $join WHERE $where " );

		return $data;

	}
}


text:
package com.lchli.angithub.features.search.bean;

import com.google.gson.annotations.SerializedName;
import com.lchli.angithub.common.base.BaseGithubResponse;

import java.util.List;

/**
 * Created by lchli on 2016/10/29.
 */

public class ReposResponse extends BaseGithubResponse {

    /**
     * total_count : 40
     * incomplete_results : false
     * items : [{"id":3081286,"name":"Tetris","full_name":"dtrupenn/Tetris","owner":{"login":"dtrupenn","id":872147,"avatar_url":"https://secure.gravatar.com/avatar/e7956084e75f239de85d3a31bc172ace?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-user-420.png","gravatar_id":"","url":"https://api.github.com/users/dtrupenn","received_events_url":"https://api.github.com/users/dtrupenn/received_events","type":"User"},"private.private":false,"html_url":"https://github.com/dtrupenn/Tetris","description":"A C implementation of Tetris using Pennsim through LC4","fork":false,"url":"https://api.github.com/repos/dtrupenn/Tetris","created_at":"2012-01-01T00:31:50Z","updated_at":"2013-01-05T17:58:47Z","pushed_at":"2012-01-01T00:37:02Z","homepage":"","size":524,"stargazers_count":1,"watchers_count":1,"language":"Assembly","forks_count":0,"open_issues_count":0,"master_branch":"master","default_branch":"master","score":10.309712}]
     */

    @SerializedName("total_count")
    public int totalCount;
    @SerializedName("incomplete_results")
    public boolean incompleteResults;
    /**
     * id : 3081286
     * name : Tetris
     * full_name : dtrupenn/Tetris
     * owner : {"login":"dtrupenn","id":872147,"avatar_url":"https://secure.gravatar.com/avatar/e7956084e75f239de85d3a31bc172ace?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-user-420.png","gravatar_id":"","url":"https://api.github.com/users/dtrupenn","received_events_url":"https://api.github.com/users/dtrupenn/received_events","type":"User"}
     * private.private : false
     * html_url : https://github.com/dtrupenn/Tetris
     * description : A C implementation of Tetris using Pennsim through LC4
     * fork : false
     * url : https://api.github.com/repos/dtrupenn/Tetris
     * created_at : 2012-01-01T00:31:50Z
     * updated_at : 2013-01-05T17:58:47Z
     * pushed_at : 2012-01-01T00:37:02Z
     * homepage :
     * size : 524
     * stargazers_count : 1
     * watchers_count : 1
     * language : Assembly
     * forks_count : 0
     * open_issues_count : 0
     * master_branch : master
     * default_branch : master
     * score : 10.309712
     */

    @SerializedName("items")
    public List<Repo> items;

    public static class Repo {
        @SerializedName("id")
        public int id;
        @SerializedName("name")
        public String name;
        @SerializedName("full_name")
        public String fullName;
        /**
         * login : dtrupenn
         * id : 872147
         * avatar_url : https://secure.gravatar.com/avatar/e7956084e75f239de85d3a31bc172ace?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-user-420.png
         * gravatar_id :
         * url : https://api.github.com/users/dtrupenn
         * received_events_url : https://api.github.com/users/dtrupenn/received_events
         * type : User
         */

        @SerializedName("owner")
        public OwnerBean owner;
        @SerializedName("private.private")
        public boolean privateX;
        @SerializedName("html_url")
        public String htmlUrl;
        @SerializedName("description")
        public String description;
        @SerializedName("fork")
        public boolean fork;
        @SerializedName("url")
        public String url;
        @SerializedName("created_at")
        public String createdAt;
        @SerializedName("updated_at")
        public String updatedAt;
        @SerializedName("pushed_at")
        public String pushedAt;
        @SerializedName("homepage")
        public String homepage;
        @SerializedName("size")
        public int size;
        @SerializedName("stargazers_count")
        public int stargazersCount;
        @SerializedName("watchers_count")
        public int watchersCount;
        @SerializedName("language")
        public String language;
        @SerializedName("forks_count")
        public int forksCount;
        @SerializedName("open_issues_count")
        public int openIssuesCount;
        @SerializedName("master_branch")
        public String masterBranch;
        @SerializedName("default_branch")
        public String defaultBranch;
        @SerializedName("score")
        public double score;

        public static class OwnerBean {
            @SerializedName("login")
            public String login;
            @SerializedName("id")
            public int id;
            @SerializedName("avatar_url")
            public String avatarUrl;
            @SerializedName("gravatar_id")
            public String gravatarId;
            @SerializedName("url")
            public String url;
            @SerializedName("received_events_url")
            public String receivedEventsUrl;
            @SerializedName("type")
            public String type;
        }
    }
}


text:
package crater

import (
	"testing"
)

func TestDefaultSettings(t *testing.T) {
	settings := DefaultSettings()

	if settings.ViewsPath != "." {
		t.Error("ViewsPath was not set correctly")
	}
	if settings.StaticPath != "." {
		t.Error("StaticPath was not set correctly")
	}
	if settings.ViewExtension != "html" {
		t.Error("ViewExtension was not set correctly")
	}
}

func TestUpdate(t *testing.T) {
	settings := DefaultSettings()

	newSettings := &Settings{
		ViewsPath:     "./folder",
		StaticPath:    "./folder",
		ViewExtension: "tmpl",
	}

	settings.Update(newSettings)

	if settings.ViewsPath != newSettings.ViewsPath {
		t.Error("ViewsPath was not set correctly")
	}
	if settings.StaticPath != newSettings.StaticPath {
		t.Error("StaticPath was not set correctly")
	}
	if settings.ViewExtension != newSettings.ViewExtension {
		t.Error("ViewExtension was not set correctly")
	}
}


text:
package org.powlab.jeye.tests.boxing;

public class BoxingTest34 {

    public void test(boolean boolean0) {
        System.out.println(Boolean.valueOf(boolean0)); // для булеан без разницы
    }
}


text:
namespace Crowbar.Tests.Mvc.Common
{
    public class Payload
    {
        public string Text { get; set; }
    }
}


text:
"""Eager-graph unified check numerics callback."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import collections
import threading

import numpy as np

from tensorflow.python.debug.lib import op_callbacks_common
from tensorflow.python.debug.lib import source_utils
from tensorflow.python.framework import op_callbacks
from tensorflow.python.ops import array_ops
from tensorflow.python.platform import tf_logging as logging
from tensorflow.python.util import compat
from tensorflow.python.util.tf_export import tf_export

def limit_string_length(string, max_len=50):
  """Limit the length of input string.

  Args:
    string: Input string.
    max_len: (int or None) If int, the length limit. If None, no limit.

  Returns:
    Possibly length-limited string.
  """
  if max_len is None or len(string) <= max_len:
    return string
  else:
    return "..." + string[len(string) - max_len:]

# A dictionary that supports looking up the original input tensor names.
_CHECK_NUMERICS_INPUT_LOOKUP = collections.defaultdict(dict)

def _maybe_lookup_original_input_tensor(graph, tensor):
  if (graph and
      graph in _CHECK_NUMERICS_INPUT_LOOKUP and
      tensor.name in _CHECK_NUMERICS_INPUT_LOOKUP[graph]):
    return _CHECK_NUMERICS_INPUT_LOOKUP[graph][tensor.name]
  else:
    return tensor

def get_check_numerics_error_message(slot,
                                     num_outputs,
                                     op_type,
                                     tensor,
                                     inputs,
                                     graph=None,
                                     traceback=None,
                                     stack_height_limit=30,
                                     path_length_limit=50):
  """Create a meaningful and user-friendly error message about offending tensor.

  The error message reveals the following info about the op that outputs
  NaN/Infinity: dtype, shape (to the extent known at graph-construction time),
  input tensors, stack trace for op creation (if is graph mode).

  Args:
    slot: (int) slot index of the tensor output.
    num_outputs: (int) total number of outputs of the op.
    op_type: (str) Type of the that generates `tensor`.
    tensor: (Tensor) the offending tensor, i.e., the tensor that contains
      Infinities or NaNs.
    inputs: (array of Tensor) inputs to the op that generates `tensor`.
    graph: (tf.Graph) the graph object that `tensor` belongs to. Available only
      under graph mode.
    traceback: (list of trace frames) the stack trace of the op's creation.
      Available only under graph model.
    stack_height_limit: (int or None) If int, limit to the height of the stack
      trace printed in the error message. If None, no limit to the height.
    path_length_limit: (int or None) Length limit for file paths included in the
      formatted stack trace.

  Returns:
    (str) A formatted error message.
  """
  eager_vs_graph_qualifier = "graph" if graph else "eagerly-executing"
  message = "\n"
  message += (
      "\n!!! Detected Infinity or NaN in output %d of "
      "%s op \"%s\" (# of outputs: %d) !!!\n" %
      (slot, eager_vs_graph_qualifier, op_type, num_outputs))

  message += "  dtype: %s\n" % tensor.dtype
  message += "  shape: %s\n" % (tensor.shape,)

  if not graph:
    # This is an eager tensor. We can get its numpy value and count
    # NaNs and Infs.
    is_inf = np.isinf(tensor)

    num_neg_inf = np.sum(np.logical_and(np.less(tensor, 0.), is_inf))
    num_pos_inf = np.sum(np.logical_and(np.greater(tensor, 0.), is_inf))
    num_nan = np.sum(np.isnan(tensor))
    if num_neg_inf > 0:
      message += "  # of -Inf elements: %s\n" % num_neg_inf
    if num_pos_inf > 0:
      message += "  # of +Inf elements: %s\n" % num_pos_inf
    if num_nan:
      message += "  # of +NaN elements: %s\n" % num_nan

  if len(inputs) > 1:
    message += "\n  Input tensors (%d):\n" % len(inputs)
    for slot, input_tensor in enumerate(inputs):
      message += "         %d: %s\n" % (
          slot, _maybe_lookup_original_input_tensor(graph, input_tensor))
  elif len(inputs) == 1:
    message += "\n  Input tensor: %s\n" % (
        _maybe_lookup_original_input_tensor(graph, inputs[0]))
  if graph and hasattr(graph, "name") and graph.name:
    message += "  Graph name: \"%s\"\n" % graph.name

  # Format the stack trace for the op's creation. We omit files that
  # belong to tensorflow itself.
  if graph and traceback:
    message += (
        "\n  Stack trace of op's creation (\"->\": inferred user code):\n")
    if stack_height_limit is not None and len(traceback) > stack_height_limit:
      num_omitted_frames = len(traceback) - stack_height_limit
      message += "    + ... (Omitted %d frames)\n" % num_omitted_frames
    for filepath, lineno, function_name, source_line in traceback[
        -stack_height_limit:]:
      user_code_indicator = "    "
      if not source_utils.guess_is_tensorflow_py_library(filepath):
        user_code_indicator = " -> "

      message += "    + %s (L%d) %s\n" % (
          limit_string_length(filepath, path_length_limit), lineno,
          function_name)
      if source_line is not None:
        message += "%s|   %s\n" % (user_code_indicator, source_line)
  message += "\n"
  return message

def _check_numerics_callback(op_type,
                             inputs,
                             attrs,
                             outputs,
                             op_name=None,
                             graph=None):
  """Eager-function unified callback for checking numerics."""
  del attrs, op_name  # Unused

  if compat.as_bytes(op_type) in op_callbacks_common.OP_CALLBACK_SKIP_OPS:
    return
  if graph:
    # Under graph mode. Insert check_numerics op.
    instrumented_outputs = []
    for slot, output in enumerate(outputs):
      if output.dtype.is_floating:
        checked_output = array_ops.check_numerics(
            output,
            get_check_numerics_error_message(
                slot, len(outputs), op_type, output, inputs,
                graph=graph, traceback=output.op.traceback))
        _CHECK_NUMERICS_INPUT_LOOKUP[graph][checked_output.name] = output
        instrumented_outputs.append(checked_output)
      else:
        instrumented_outputs.append(output)
    return instrumented_outputs
  else:
    if compat.as_bytes(op_type) == b"CheckNumerics":
      # TODO(b/140334369): Remove this special casing logic once op_callback.
      # automatically prevents infinite recursion in eager mode.
      return
    # Under eager mode. Eagerly execute check_numerics op.
    for slot, output in enumerate(outputs):
      if output.dtype.is_floating:
        array_ops.check_numerics(
            output,
            get_check_numerics_error_message(
                slot, len(outputs), op_type, output, inputs,
                stack_height_limit=_state.config.stack_height_limit,
                path_length_limit=_state.config.path_length_limit))

CheckNumericsConfig = collections.namedtuple(
    "CheckNumericsConfig", "stack_height_limit path_length_limit")
_state = threading.local()

@tf_export("debugging.enable_check_numerics")
def enable_check_numerics(stack_height_limit=30,
                          path_length_limit=50):
  r"""Enable tensor numerics checking in an eager/graph unified fashion.

  The numerics checking mechanism will cause any TensorFlow eager execution or
  graph execution to error out as soon as an op's output tensor contains
  infinity or NaN.

  This method is idempotent. Calling it multiple times has the same effect
  as calling it once.

  This method takes effect only on the thread in which it is called.

  When a op's float-type output tensor contains any Infinity or NaN, an
  `tf.errors.InvalidArgumentError` will be thrown, with an error message that
  reveals the following information:
    - The type of the op that generated the tensor with bad numerics.
    - Data type (dtype) of the tensor.
    - Shape of the tensor (to the extent known at the time of eager execution
      or graph construction).
    - Name of the containing graph (if available).
    - (Graph mode only): The stack trace of the intra-graph op's creation,
      with a stack-height limit and a path-length limit for visual clarity.
      The stack frames that belong to the user's code (as opposed to
      tensorflow's internal code) are highlighted with a text arrow ("->").
    - (Eager mode only): How many of the offending tensor's elements are
      `Infinity` and `NaN`, respectively.

  Once enabled, the check-numerics mechanism can be disabled by using
  `tf.debugging.disable_check_numerics()`.

  Example usage:

  1. Catching infinity during the execution of a `tf.function` graph:

     ```py
     import tensorflow as tf

     tf.debugging.enable_check_numerics()

     @tf.function
     def square_log_x_plus_1(x):
       v = tf.math.log(x + 1)
       return tf.math.square(v)

     x = -1.0

     # When the following line runs, a function graph will be compiled
     # from the Python function `log_x_plus_1()`. Due to the
     # `enable_check_numerics()` call above, the graph will contain
     # numerics checking ops that will run during the function graph's
     # execution. The function call generates an -infinity when the Log
     # (logarithm) op operates on the output tensor of the Add op.
     # The program errors out at this line, printing an error message.
     y = log_x_plus_1(x)
     z = -y
    ```

  2. Catching NaN during eager execution:

     ```py
     import numpy as np
     import tensorflow as tf

     tf.debugging.enable_check_numerics()

     x = np.array([[0.0, -1.0], [4.0, 3.0]])

     # The following line executes the Sqrt op eagerly. Due to the negative
     # element in the input array, a NaN is generated. Due to the
     # `enable_check_numerics()` call above, the program errors immediately
     # at this line, printing an error message.
     y = tf.math.sqrt(x)
     z = tf.matmul(y, y)
     ```

  Args:
    stack_height_limit: Limit to the height of the printed stack trace.
      Applicable only to ops in `tf.function`s (graphs).
    path_length_limit: Limit to the file path included in the printed stack
      trace. Applicable only to ops in `tf.function`s (graphs).
  """

  if not hasattr(_state, "config"):
    _state.config = CheckNumericsConfig(
        stack_height_limit=stack_height_limit,
        path_length_limit=path_length_limit)
  op_callbacks.add_op_callback(_check_numerics_callback)

  logging.info(
      "Enabled check-numerics callback in thread %s",
      threading.current_thread().name)

@tf_export("debugging.disable_check_numerics")
def disable_check_numerics():
  """Disable the eager/graph unified numerics checking mechanism.

  This method can be used after a call to `tf.debugging.enable_check_numerics()`
  to disable the numerics-checking mechanism that catches inifnity and NaN
  values output by ops executed eagerly or in tf.function-compiled graphs.

  This method is idempotent. Calling it multiple times has the same effect
  as calling it once.

  This method takes effect only on the thread in which it is called.
  """
  try:
    op_callbacks.remove_op_callback(_check_numerics_callback)
    logging.info(
        "Disabled check-numerics callback in thread %s",
        threading.current_thread().name)
  except KeyError:
    # Tolerate disabling the check numerics callback without
    # enable_check_numerics() being called first.
    pass


text:
/*
 * volume.js: OpenStack Block Storage snapshot
 *
 * (C) 2014 Rackspace
 *      Ken Perkins
 * MIT LICENSE
 *
 */

var util = require('util'),
    base = require('../../core/base'),
    _ = require('lodash');

var Snapshot = exports.Snapshot = function Snapshot(client, details) {
  base.Model.call(this, client, details);
};

util.inherits(Snapshot, base.Model);

Snapshot.prototype._setProperties = function (details) {
  this.id = details.id;
  this.status = details.status;
  this.name = details.name || details['display_name'];
  this.description = details.description || details['display_description'];
  this.createdAt = details['created_at'];
  this.volumeId = details['volume_id'];
  this.size = details.size;
  this.metadata = details.metadata;
};

Snapshot.prototype.toJSON = function () {
  return _.pick(this, ['id', 'status', 'name', 'description', 'createdAt', 'size', 'volumeId', 'metadata']);
};


text:
<?php
use \BambooCMS\Controller,
    \BambooCMS\Templating\FileTemplate;

class HomepageController extends Controller {

    public function prepare( $action ) {
        $this->template = new FileTemplate( 'homepage', $this->config );
    }

    public function render( $action ) {
        $this->template->addVariable( 'test', $action );
    }
}


text:
using BusinessObjects;
using BusinessObjects;
using BusinessObjects.Validators;
using FatturaElettronicaPA.Validators;
using System.Collections.Generic;
using System.Xml;

namespace FatturaElettronicaPA.FatturaElettronicaHeader
{
    public class FatturaElettronicaHeader : Common.BusinessObject
    {
        private readonly DatiTrasmissione.DatiTrasmissione _datiTrasmissione;
        private readonly CedentePrestatore.CedentePrestatore _cedentePrestatore;
        private readonly RappresentanteFiscale.RappresentanteFiscale _rappresentanteFiscale;
        private readonly CessionarioCommittente.CessionarioCommittente _cessionarioCommittente;
        private readonly TerzoIntermediarioOSoggettoEmittente.TerzoIntermediarioOSoggettoEmittente
            _terzoIntermediarioOSoggettoEmittente;

        /// <summary>
        /// Intestazione della Fattura Elettronica.
        /// </summary>
        public FatturaElettronicaHeader() {
            _datiTrasmissione = new DatiTrasmissione.DatiTrasmissione();
            _cedentePrestatore = new CedentePrestatore.CedentePrestatore();
            _rappresentanteFiscale = new RappresentanteFiscale.RappresentanteFiscale();
            _cessionarioCommittente = new CessionarioCommittente.CessionarioCommittente();
            _terzoIntermediarioOSoggettoEmittente = new TerzoIntermediarioOSoggettoEmittente.TerzoIntermediarioOSoggettoEmittente();
        }
        public FatturaElettronicaHeader(XmlReader r) : base(r) { }

        protected override List<Validator> CreateRules() {
            var rules = base.CreateRules();
            rules.Add(new FRequiredValidator("DatiTrasmissione"));
            rules.Add(new FRequiredValidator("CedentePrestatore"));
            rules.Add(new FRequiredValidator("CessionarioCommittente"));
            rules.Add(new DomainValidator("SoggettoEmittente", string.Empty, Common.SoggettoEmittente.Codici));
            return rules;
        }

        #region Properties

        /// IMPORTANT
        /// Each data property must be flagged with the Order attribute or it will be ignored.
        /// Also, properties must be listed with the precise order in the specification.

        /// <summary>
        /// Informazioni che identificano univocamente il soggetto che trasmette, il documento trasmesso,
        /// il formato in cui è stato trasmesso il documento, il soggetto destinatario.
        /// </summary>
        [DataProperty]
        public DatiTrasmissione.DatiTrasmissione DatiTrasmissione { get { return _datiTrasmissione; } }

        /// <summary>
        /// Dati relativi al cedente / prestatore.
        /// </summary>
        [DataProperty]
        public CedentePrestatore.CedentePrestatore CedentePrestatore { get { return _cedentePrestatore; } }

        /// <summary>
        /// Dati relativi al rappresentante fiscale del cedente / prestatore.
        /// </summary>
        [DataProperty]
        public RappresentanteFiscale.RappresentanteFiscale Rappresentante { get { return _rappresentanteFiscale; } }

        /// <summary>
        /// Dati relativi al cessionario / committente
        /// </summary>
        [DataProperty]
        public CessionarioCommittente.CessionarioCommittente CessionarioCommittente { get { return _cessionarioCommittente; } }

        /// <summary>
        /// Dati relativi al soggetto che emette fattura per conto del cedente / prestatore.
        /// </summary>
        [DataProperty]
        public TerzoIntermediarioOSoggettoEmittente.TerzoIntermediarioOSoggettoEmittente TerzoIntermediarioOSoggettoEmittente {
            get { return _terzoIntermediarioOSoggettoEmittente; }
        }

        /// <summary>
        /// Nei casi di documenti emessi da un soggetto diverso dal cedente / prestatore, indica se la fattura sia stata
        /// emessa o da parte del cessionario / committente oppure da parte di un terzo per conto del cedente / prestatore.
        /// </summary>
        [DataProperty]
        public string SoggettoEmittente { get; set; }
        #endregion
    }
}


text:
package ucar.util;

/**
 * An object that has a name and a description.
 *
 * @author caron
 */

public interface NamedObject {

  /**
   * Get the object's name
   *
   * @return object's name
   */
  String getName();

  /**
   * Get the object's description. Use as a tooltip, for example
   *
   * @return object's description
   */
  String getDescription();

  // the object itself
  Object getValue();

}


text:
Make sure to install all the [prerequisites](https://github.com/Dickurt/vscode-php-formatter/wiki/Prerequisites). Without them, none of this will work.

1. Based on your installation method of PHP-CS-Fixer, use one of the following settings:

   ---

   ### **With Composer**

   Add Composer to your PATH environment variable. E.g. on Windows: `%APPDATA%\Composer\vendor\bin`. E.g. on Linux: `/.composer/vendor/bin`.

   Add `"phpformatter.composer": true` to your VSCode user settings.

   ![VSCode user settings result with Composer](https://github.com/Dickurt/vscode-php-formatter/blob/master/images/install-composer.jpg?raw=true "VSCode user settings result with Composer")

   ---

   ### **Manual**

   Add PHP to your PATH environment variable. I.e. ensure that `php -v` works. Otherwise use `"phpformatter.phpPath" = "/path/to/php/executable"`.

   Point the `phpformatter.pharPath` setting to where you put the php-cs-fixer file.

   ![VSCode user settings result with Manual](https://github.com/Dickurt/vscode-php-formatter/blob/master/images/install-manual.jpg?raw=true "VSCode user settings result with Manual")

   *Not working?* Make sure the `phpformatter.composer` setting is set to `false`, which it is by default.

   ---

2. To format a file with a custom keybinding or action, see [Extension Commands](#commands).
3. Done! Restart all instances of Visual Studio Code.


text:
namespace CatSkald.Roguelike.Core.Messages
{
    public struct GameMessage
    {
        public GameMessage(MessageType type) : this(type, null)
        {
        }

        public GameMessage(MessageType type, params object[] args)
        {
            Type = type;
            Args = args;
        }

        public MessageType Type { get; }
        public object[] Args { get; }
    }
}


text:
import {Feature, FeatureCollection} from './constants';
import {Transform} from 'vega-dataflow';
import {projection, projectionProperties} from 'vega-projection';
import {array, error, inherits, isFunction} from 'vega-util';

/**
 * Maintains a cartographic projection.
 * @constructor
 * @param {object} params - The parameters for this operator.
 */
export default function Projection(params) {
  Transform.call(this, null, params);
  this.modified(true); // always treat as modified
}

inherits(Projection, Transform, {
  transform(_, pulse) {
    let proj = this.value;

    if (!proj || _.modified('type')) {
      this.value = (proj = create(_.type));
      projectionProperties.forEach(prop => {
        if (_[prop] != null) set(proj, prop, _[prop]);
      });
    } else {
      projectionProperties.forEach(prop => {
        if (_.modified(prop)) set(proj, prop, _[prop]);
      });
    }

    if (_.pointRadius != null) proj.path.pointRadius(_.pointRadius);
    if (_.fit) fit(proj, _);

    return pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS);
  }
});

function fit(proj, _) {
  const data = collectGeoJSON(_.fit);
  _.extent ? proj.fitExtent(_.extent, data)
    : _.size ? proj.fitSize(_.size, data) : 0;
}

function create(type) {
  const constructor = projection((type || 'mercator').toLowerCase());
  if (!constructor) error('Unrecognized projection type: ' + type);
  return constructor();
}

function set(proj, key, value) {
   if (isFunction(proj[key])) proj[key](value);
}

export function collectGeoJSON(data) {
  data = array(data);
  return data.length === 1 ? data[0]
    : {
        type: FeatureCollection,
        features: data.reduce((a, f) => a.concat(featurize(f)), [])
      };
}

function featurize(f) {
  return f.type === FeatureCollection
    ? f.features
    : array(f).filter(d => d != null).map(
        d => d.type === Feature ? d : {type: Feature, geometry: d}
      );
}


text:
/*angular.module("myapp", [])
 .controller("fisrtcontroller", function($scope, $http) {
 $http({
  method: 'GET',
       url: 'http://jsonplaceholder.typicode.com/posts'
    }).then(function (data){
     console.log(data);
    },function (error){

    })
});*/
angular
.module("myapp",[])
.controller("fisrtcontroller",function($scope,$http){
	console.log('success');

	$http.post('http://localhost/creaciones/Cpedidomultiple/dependencia/')
	.then(function(mydata){
		console.log(mydata);

	})

});


text:
#ifndef portability_h
#define	portability_h

/*
 * Helpers for portability between Windows and UN*X and between different
 * flavors of UN*X.
 */

#include "pcap/funcattrs.h"

#ifdef __cplusplus
extern "C" {
#endif

#ifndef HAVE_STRLCPY
 /*
  * Macro that does the same thing as strlcpy().
  */
 #if defined(_MSC_VER) || defined(__MINGW32__)
  /*
   * strncpy_s() is supported at least back to Visual
   * Studio 2005.
   */
  #define strlcpy(x, y, z) \
	strncpy_s((x), (z), (y), _TRUNCATE)

 #else
  #define strlcpy(x, y, z) \
	(strncpy((x), (y), (z)), \
	 ((z) <= 0 ? 0 : ((x)[(z) - 1] = '\0')), \
	 (void) strlen((y)))
 #endif
#endif

#ifndef HAVE_STRLCAT
 /*
  * Macro that does the same thing as strlcat().
  */
 #if defined(_MSC_VER) || defined(__MINGW32__)
  /*
   * strncat_s() is supported at least back to Visual
   * Studio 2005.
   */
  #define strlcat(x, y, z) \
	strncat_s((x), (z), (y), _TRUNCATE)
 #else
  /*
   * ANSI C says strncat() always null-terminates its first argument,
   * so 1) we don't need to explicitly null-terminate the string
   * ourselves and 2) we need to leave room for the null terminator.
   */
  #define strlcat(x, y, z) \
	strncat((x), (y), (z) - strlen((x)) - 1)
 #endif
#endif

#ifdef _MSC_VER
  /*
   * If <crtdbg.h> has been included, and _DEBUG is defined, and
   * __STDC__ is zero, <crtdbg.h> will define strdup() to call
   * _strdup_dbg().  So if it's already defined, don't redefine
   * it.
   */
  #ifndef strdup
  #define strdup	_strdup
  #endif
#endif

/*
 * On Windows, snprintf(), with that name and with C99 behavior - i.e.,
 * guaranteeing that the formatted string is null-terminated - didn't
 * appear until Visual Studio 2015.  Prior to that, the C runtime had
 * only _snprintf(), which *doesn't* guarantee that the string is
 * null-terminated if it is truncated due to the buffer being too
 * small.  We therefore can't just define snprintf to be _snprintf
 * and define vsnprintf to be _vsnprintf, as we're relying on null-
 * termination of strings in all cases.
 *
 * We also want to allow this to be built with versions of Visual Studio
 * prior to VS 2015, so we can't rely on snprintf() being present.
 *
 * And we want to make sure that, if we support plugins in the future,
 * a routine with C99 snprintf() behavior will be available to them.
 * We also don't want it to collide with the C library snprintf() if
 * there is one.
 *
 * So we make pcap_snprintf() and pcap_vsnprintf() available, either by
 * #defining them to be snprintf or vsnprintf, respectively, or by
 * defining our own versions and exporting them.
 */
#ifdef HAVE_SNPRINTF
#define pcap_snprintf snprintf
#else
extern int pcap_snprintf(char *, size_t, PCAP_FORMAT_STRING(const char *), ...)
    PCAP_PRINTFLIKE(3, 4);
#endif

#ifdef HAVE_VSNPRINTF
#define pcap_vsnprintf vsnprintf
#else
extern int pcap_vsnprintf(char *, size_t, const char *, va_list ap);
#endif

#ifdef HAVE_STRTOK_R
  #define pcap_strtok_r	strtok_r
#else
  #ifdef _WIN32
    /*
     * Microsoft gives it a different name.
     */
    #define pcap_strtok_r	strtok_s
  #else
    /*
     * Define it ourselves.
     */
    #define NEED_STRTOK_R
    extern char *pcap_strtok_r(char *, const char *, char **);
  #endif
#endif /* HAVE_STRTOK_R */

#ifdef _WIN32
  #if !defined(__cplusplus)
    #define inline __inline
  #endif
#endif /* _WIN32 */

#ifdef __cplusplus
}
#endif

#endif


text:
.class Lcom/android/internal/widget/ActionBarView$SavedState;
.super Landroid/view/View$BaseSavedState;
.source "ActionBarView.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Lcom/android/internal/widget/ActionBarView;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x8
    name = "SavedState"
.end annotation

# static fields
.field public static final CREATOR:Landroid/os/Parcelable$Creator;
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "Landroid/os/Parcelable$Creator",
            "<",
            "Lcom/android/internal/widget/ActionBarView$SavedState;",
            ">;"
        }
    .end annotation
.end field

# instance fields
.field expandedMenuItemId:I

.field isOverflowOpen:Z

# direct methods
.method static constructor <clinit>()V
    .locals 1

    .prologue
    .line 1383
    new-instance v0, Lcom/android/internal/widget/ActionBarView$SavedState$1;

    invoke-direct {v0}, Lcom/android/internal/widget/ActionBarView$SavedState$1;-><init>()V

    sput-object v0, Lcom/android/internal/widget/ActionBarView$SavedState;->CREATOR:Landroid/os/Parcelable$Creator;

    return-void
.end method

.method private constructor <init>(Landroid/os/Parcel;)V
    .locals 1
    .parameter "in"

    .prologue
    .line 1371
    invoke-direct {p0, p1}, Landroid/view/View$BaseSavedState;-><init>(Landroid/os/Parcel;)V

    .line 1372
    invoke-virtual {p1}, Landroid/os/Parcel;->readInt()I

    move-result v0

    iput v0, p0, Lcom/android/internal/widget/ActionBarView$SavedState;->expandedMenuItemId:I

    .line 1373
    invoke-virtual {p1}, Landroid/os/Parcel;->readInt()I

    move-result v0

    if-eqz v0, :cond_0

    const/4 v0, 0x1

    :goto_0
    iput-boolean v0, p0, Lcom/android/internal/widget/ActionBarView$SavedState;->isOverflowOpen:Z

    .line 1374
    return-void

    .line 1373
    :cond_0
    const/4 v0, 0x0

    goto :goto_0
.end method

.method synthetic constructor <init>(Landroid/os/Parcel;Lcom/android/internal/widget/ActionBarView$1;)V
    .locals 0
    .parameter "x0"
    .parameter "x1"

    .prologue
    .line 1362
    invoke-direct {p0, p1}, Lcom/android/internal/widget/ActionBarView$SavedState;-><init>(Landroid/os/Parcel;)V

    return-void
.end method

.method constructor <init>(Landroid/os/Parcelable;)V
    .locals 0
    .parameter "superState"

    .prologue
    .line 1367
    invoke-direct {p0, p1}, Landroid/view/View$BaseSavedState;-><init>(Landroid/os/Parcelable;)V

    .line 1368
    return-void
.end method

# virtual methods
.method public writeToParcel(Landroid/os/Parcel;I)V
    .locals 1
    .parameter "out"
    .parameter "flags"

    .prologue
    .line 1378
    invoke-super {p0, p1, p2}, Landroid/view/AbsSavedState;->writeToParcel(Landroid/os/Parcel;I)V

    .line 1379
    iget v0, p0, Lcom/android/internal/widget/ActionBarView$SavedState;->expandedMenuItemId:I

    invoke-virtual {p1, v0}, Landroid/os/Parcel;->writeInt(I)V

    .line 1380
    iget-boolean v0, p0, Lcom/android/internal/widget/ActionBarView$SavedState;->isOverflowOpen:Z

    if-eqz v0, :cond_0

    const/4 v0, 0x1

    :goto_0
    invoke-virtual {p1, v0}, Landroid/os/Parcel;->writeInt(I)V

    .line 1381
    return-void

    .line 1380
    :cond_0
    const/4 v0, 0x0

    goto :goto_0
.end method


text:
<!DOCTYPE html>

        <meta http-equiv="X-UA-Compatible" content="IE=edge" />
        <meta http-equiv="pragma" content="no-cache"/>
        <meta name="apple-mobile-web-app-capable" content="yes" />
        <meta name ="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0" />
        <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
        <meta charset="utf-8"/>

        <title>Created with GameMaker:Studio</title>

            <canvas id="canvas" width="1200" height="680">

Your browser doesn't support HTML5 canvas.

            </canvas>

		<audio preload="auto" networkstate="0">
			<source src="html5game/snd_background_music.ogg" type="audio/ogg" codecs="vorbis">
			<source src="html5game/snd_background_music.mp3" type="audio/mp3" codecs="vorbis">
		</audio>

		<audio preload="auto" networkstate="0">
			<source src="html5game/snd_block_hit.ogg" type="audio/ogg" codecs="vorbis">
			<source src="html5game/snd_block_hit.mp3" type="audio/mp3" codecs="vorbis">
		</audio>

		<audio preload="auto" networkstate="0">
			<source src="html5game/snd_paddle_hit.ogg" type="audio/ogg" codecs="vorbis">
			<source src="html5game/snd_paddle_hit.mp3" type="audio/mp3" codecs="vorbis">
		</audio>

		<audio preload="auto" networkstate="0">
			<source src="html5game/sound3_game_over.ogg" type="audio/ogg" codecs="vorbis">
			<source src="html5game/sound3_game_over.mp3" type="audio/mp3" codecs="vorbis">
		</audio>

		<audio preload="auto" networkstate="0">
			<source src="html5game/sound4_light_switch_019.ogg" type="audio/ogg" codecs="vorbis">
			<source src="html5game/sound4_light_switch_019.mp3" type="audio/mp3" codecs="vorbis">
		</audio>

		<audio preload="auto" networkstate="0">
			<source src="html5game/snd_tiro.ogg" type="audio/ogg" codecs="vorbis">
			<source src="html5game/snd_tiro.mp3" type="audio/mp3" codecs="vorbis">
		</audio>


text: another test repository


text:
<?php
/**
 * Created by PhpStorm.
 * User : xin.zhang
 * Date : 15/4/2
 * Time : 下午1:58
 * Email: zhangxinmailvip@foxmail.com
 */
namespace backend\controllers;

use Yii;

class UserCenterController extends CController
{
    public function actionIndex(){
        echo '11111';
    }

    public function actionIndexTest(){
        echo "test";
    }

    public function actionMyBook(){
        echo "myBook";
    }

    public function actionMyCourse(){
        echo "myCourse";

    }
}


text: precontract a time


text:
<?php

namespace Projx\MessagingBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Symfony\Component\HttpFoundation\Request;

class MessagingController extends Controller {

	/**
	 * @Route("/user/inbox", name="messaging_inbox")
	 * @Template()
	 */
	public function inboxAction() {
		$user = $this->get('security.context')->getToken()->getUser();
		$provider = $this->container->get('fos_message.provider');
		$threads = $provider->getInboxThreads();

		$profiles = array();

		if (!empty($threads)) {
			// Get Profiles for each thread participant
			foreach ($threads as $k => $v) {
				foreach ($v->getParticipants() as $participant) {
					$profiles[$participant->getId()] = $this->getDoctrine()->getRepository('ProjxUserAccountBundle:Profile')->find($participant->getId());
				}
			}
		}

		$numberUnread = $provider->getNbUnreadMessages();

		return array(
			'user' => $user,
			'threads' => $threads,
			'profiles' => $profiles,
			'numberUnread' => $numberUnread
		);
	}

	/**
	 * @Route("/user/{userId}/message", name="send_message")
	 * @Template()
	 */
	public function sendMessageAction(Request $request, $userId) {
		$actualUserId = $userId - $this->container->getParameter('projx_user_id_offset');
		$participant = $this->getDoctrine()
			->getRepository('ProjxUserAccountBundle:Profile')
			->find($actualUserId);

		if ($request->getMethod() == 'POST') {
			$composer = $this->container->get('fos_message.composer');
			$sender = $this->container->get('fos_message.sender');

			$user = $this->get('security.context')->getToken()->getUser();

			$messageBody = $request->request->get('_messageBody');
			$subject = $request->request->get('_subject');
			$recipient = $participant->getUser();

			$message = $composer->newThread()
				->setSender($user)
				->addRecipient($recipient)
				->setSubject($subject)
				->setBody($messageBody)
				->getMessage();

			$sender->send($message);

			return $this->redirect($this->generateUrl('messaging_inbox'));
		}

		return array('participant' => $participant);
	}

	/**
	 * @Route("user/message/reply", name="message_reply")
	 */
	public function replyAction(Request $request) {
		$user = $this->get('security.context')->getToken()->getUser();

		if ($request->getMethod() == 'POST') {
			$threadId = ($request->request->get('_thread'));
			$provider = $this->container->get('fos_message.provider');
			$thread = $provider->getThread($threadId);
			$body = ($request->request->get('_messageBody'));

			$composer = $this->container->get('fos_message.composer');
			$message = $composer->reply($thread)
				->setSender($user)
				->setBody($body)
				->getMessage($body);

			$sender = $this->container->get('fos_message.sender');
			$sender->send($message);
		}

		return $this->redirect($this->generateUrl('messaging_inbox'));
	}

}