text:
The `SymPy` package for `julia` brings the symbolic math capabilities
of Python's `sympy` to `julia` users through the `PyCall` package

The `sympy` package (http://sympy.org/) is a Python library for symbolic mathematics. With the excellent `PyCall` package of `julia`, one has access to the many features of `sympy` from a `julia` session.

This `SymPy` package provides a light interface for _some_ of the
features of `SymPy` that makes working with `SymPy` objects a bit
easier.

To use it both `Python` and its `SymPy` package must be installed on
your system. (Install `Python` then download the `sympy` library from
http://code.google.com/p/sympy/downloads/list and install.) [This may
not work on Windows until the zlib issue is resolved.]

## The `PyCall` interface to `SymPy`

The only point to this package is that using `PyCall` to access
`SymPy` is somewhat cumbersome. The following is how one would define
a symbolic value `x`, take its sine, then evaluate at `pi`, say:

```
using PyCall
@pyimport sympy
#
x = sympy.Symbol("x")
y = sympy.sin(x)
y[:subs](x, pi) |> float
```

The `Symbol` and `sin` function of `SymPy` are found within the
imported `sympy` object. They may be conveniently referenced with
`Python`'s dot notation from the imported `sympy` object, which can be
shortened if desired. However, the `subs` instance method of the `y`
object is accessed differently with `PyCall`: indexing with a
symbol. This returns a function to which we pass the symbolic object
`x` and a value to substitute `pi`.  This leaves the object as a
`PyObject` storing a number which can be brought back into `julia`
through conversion, in this case with the `float` function.

The above isn't so awkward, but  more cumbersome is the similarly
simple task of finding `sin(pi*x)`.  As this multiplication is done at
the python level and is not a method of `sympy` or the `x` object, we
need to evaluate python code. Here is one solution:

```
x = sympy.Symbol("x")
y = pyeval("k*x", k=pi, x=x)    # PyObject 3.14159265358979*x
z = sympy.sin(y)		# PyObject sin(3.14159265358979*x)
z[:subs](x, 1) |> float		# 1.2246467991473532e-16
```

It is possible to simply define operations for `PyObjects`s but
instead, `SymPy` wraps these into a new type, `Sym`.  So, with `SymPy`
this gets replaced by a more `julia`n syntax:

```
using SymPy                     # some warnings need cleaning up
x = sym"x"			# or Sym("x") or Sym(:x) or @syms x
y = sin(pi*x)
subs(y, x, 1) |> float
```

The object `x` we create is of type `Sym`, a simple proxy for the
underlying `PyObject`. The `SymPy` package overloads the familiar math
functions so that working with symbolic expressions can use natural
`julia` idioms.  The `PyCall` interface is always in the
background. To dig the `PyObject` out of a `Sym` object, you access
its property `x`, as in `y.x`.

## Examples

### Making symbolic objects

`SymPy` adds symbolic math to `julia`. Performing symbolic operations
begins by defining simple symbolic objects.  There are many different
ways to make a symbolic object:

```
x = Sym("x")			# Sym constructor
a = Sym(:a)			# using a symbol, not a string
@syms alpha gamma delta # @syms macro
A, B = symbols("A B", commutative=false) # symbols takes assertions as keyword arguments
```

Each new value is a symbolic value.

### Working with symbolic object

The package overloads many basic math functions to work with this
object type, returning a symbolic object for further manipulations:

```
1/x + 1/x^2 + x			# pretty prints x + 1/x + 1/x^2
```

```
sin(y*x)^2 - cos(y*x)^2
```

## substituting

The `subs` command is used to substitute values. These values are
typically numeric, though they may be other symbols:

```
x,y = symbols("x,y")
subs(x + y, x, 3)     # y + 3
subs(x*y, y, 24 - 2x) # x*(-2*x + 24)
```

Even when the value is numeric, the result of `subs` is a symbolic
object. To bring into `julia`, one must coerce the value with `float`
or `int`, say.

### Conversion

Basic conversions from `SymPy` numeric types to the corresponding
`julia` objects may be done with the functions `integer`, `float`, and
`complex`. Rational expressions can be converted through
`convert(Rational, ex)`.

```
x |> subs(x, 1) |> int
convert(Rational, sympy.harmonic(30))
```

Sympy has both `N` and `evalf` for conversion. We use `N` to convert to a julia value and `evalf` for numeric conversions within SymPy.

```
evalf(PI) # a Sym object
```

```
N(PI)   # a Float64 value
```

We can pass in an argument to control the number of digits

```
evalf(PI, 60) # still symbolic
```

```
N(PI, 60)  # a BigFloat with precision given by a heuristic
```

### Printing

By default, `SymPy`'s pretty printing is used. This works well enough,
though arrays can get squeezed for space. The `_str` function (not
exported currently) can give a more basic output (from `Python`'s
`__str__` method for objects):

```
x = sym"x"
1/x
[1/x, 1/x^2]
map(SymPy._str,[1/x, 1/x^2])
```

## Mathematics

What does `SymPy` bring to the `julia` user? Basically, the
opportunity to manipulate symbolic expressions. The goal is to provide
a comfortable `julia`-like interface, without worrying about
speed. (There are excess conversions between `PyObject` and `Sym`
objects, ...)

### algebraic expressions

The package provides several functions for working with algebraic expressions.

The `factor` and `expand` functions perform the tasks learned in basic algebra:

```
x,y  = symbols("x, y")
factor(x^2 - 2x + 1)
factor(x^2 - 2x*y + y^2)
expand((x-1)*(x+1))
expand(prod([x-i for i in 1:5]))

```

Rational expressions can be combined with `together` and taken apart through a partial fraction decomposition with `apart`:

```
together(1/x + 1/x^2 + x)	# (x^3 + x + 1) / x^2
```
```
apart(1/(x +2)/(x + 1))		# -1/(x+2) + 1/(x+1)
```

There are a number of different simplification methods: `simplify` is the main one:

```
a = (x + x^2)/(x*sin(y)^2 + x*cos(y)^2)
simplify(a)			# x + 1
```

There are also special purpose simplification functions, such as `trigsimp` (others are listed at http://docs.sympy.org/0.7.2/modules/simplify/simplify.html):

```
trigsimp(a)			# (x^2 + x) / x
```

The `simplify` function has an argument `ratio` to determine how aggressive the simplification should be:

```
root = 1/(sqrt(x) + 3) |> subs(x, 2) # want sqrt(2) to be symbolic
simplify(root, ratio=1)		   # 1/(sqrt(2) + 3)
simplify(root, ratio=oo)	   # -2/sqrt(7) + 3/sqrt(7)
```

The default  is $1.7$.

### Plotting

Plotting is provided through the `Plots` package. Where a function can be used in `Plots`, a symbolic expression can be used.

```
using Plots
```

```
x = symbols("x")
f(x) = exp(-x) * sin(x)		# a julia function
```

```{asis=true}
plot(f(x), 0, 2pi)
```

```{asis=true}
plot( [sin(x), diff(sin(x)) ], 0, 2pi) # two plots
```

### Solving equations

The `solve` function provides an interface to solve equations of the type `ex = 0`

```
x,y,a,b,c  = symbols("x y a b c")
solve(x^2 + 3*x + 2, x)
solve(a*x^2 + b*x + c, x)
```

Simultaneous equations can be specified with vector notation:

```
eq1 = x + y - 1
eq2 = x - y - 2
solve([eq1, eq2], [x, y])	# {"x"=>3/2,"y"=>-1/2}
```

The `nsolve` function provides numeric solutions to one or more
equations. Again equations are written as expressions equal to
$0$. Unlike `solve`, the `nsolve` function requires a starting point.

```
nsolve(sin(x) - cos(x), x, 0)
##
x1, x2 = symbols("x1", "x2")
f1 = 3 * x1^2 - 2 * x2^2 - 1
f2 = x1^2 - 2 * x1 + x2^2 + 2 * x2 - 8
nsolve([f1,f2], [x1,x2], [-1,1])
```

### Limits

The `limit` function can be used to compute limits:

```
x, y = symbols("x y")
limit(sin(x)/x, x, 0)		# 1 as Sym object. Use integer() or float() to convert
limit(sin(y*x)/x, x, 0)		# y
limit(sin(y*x)/x, y, 0) 	# 0
```

One can take limits at infinity using `oo` (but not `Inf`):

```
limit(sin(x)/x, x, oo)		# 0
```

One could take derivatives "by hand":

```
x, h = symbols("x h")
f(x) = sin(x)
limit(( f(x+h) - f(x) ) /h, h, 0)
```

Even with more complicated  expressions for the derivative:

```
D(F::Function, x, h) =  (-f(x + 2h) + 8f(x+h) - 8f(x-h) + f(x-2h))/(12h)
limit(D(sin, x, h), h, 0)
```

### Derivatives

The `diff` function is used to compute  derivative of symbolic expressions. One can compute partial derivatives and higher order derivatives:

```
x, y = symbols("x y")
f(x) = exp(-x) * sin(x)
g(x, y) = x^2 + 17*x*y^2
diff(f(x))
diff(f(x), x)			# single variable is redundant
diff(f(x), x, 3)		# f'''(x)
##
diff(sinh(x^2+sqrt(x-1)), x, 3)	# complicated answers
##
diff(g(x,y), x)			# partial in x
diff(g(x,y), x, y)		# mixed partial
```

We can make tangent lines:

```
f(x) = x^x
c = 2
m = diff(f(x), x) |> subs(x, c)
```

```
plot([f(x), f(c) + m*(x-c)], 1, 3)
```

We can solve max and min problems. For example, a normal window with perimeter 20:

```
x,y = symbols("x y")
Area(x, y) = x*y + pi*(x/2)^2/2
y0 = solve(2y + x + pi/2*x - 20, y)[1]
solve(diff(Area(x, y0)), x)
```

### Integration

The `integrate` function provides symbolic integration. (http://docs.sympy.org/0.7.2/modules/integrals/integrals.html)

Indefinite integrals can be computed:

```
x,y,a,b,c = symbols("x y a b c")
integrate(x^2 + x + 2)
integrate(1/((1+x)*(x-1)))
integrate(a*x^2 + b*x + c, x)	# if more than one symbol, specify here
```

Double integrals can be done as well:

```
integrate(x*y, x, y)
```

Definite integrals are specified using tuples:

```
integrate(x^2, (x, 0, 1))
integrate(x*y, (x, 0, 1), (y, 0, 1))
integrate(Sym(1), (x, y, 1), (y, 0, 1)) # 0 <= y <= x <= 1
```

### Taylor series

A Taylor series is an expansion of a function around a point $x_0$, terminating a certain degree, $n$. The `series` function will compute the expansion. One can specify the value of $x_0$ (default is 0$, the degree $n$ (default is $6$). For example, for the function $\sin(x)$, the defaults produce:

```
series(sin(x), x)			# uses x0=0, n=6
```

To find an expansion around another point, say $pi/4$, we would have:

```
series(sin(x), x, pi/4)
```

To get more terms, say up to degree 10, could be done with:

```
series(sin(x), x, pi/4, 10)
```

### Series

Sympy has some functions for dealing with sums, finite and infinite. The `Sum` function is used in a similar manner as `integrate`. Here we find the sum of $1/i^2$:

```
i, n = symbols("i, n")
Sum(1/i^2, (i, 1, oo))
Sum(1/i^2, (i, 1, oo)) |> doit
```

Finite sums are also computable using rational math:

```
Sum(1/i, (i, 1, 100)) |> doit
```

## Matrices

The sympy package has a matrix class that can treat matrices as
symbolic objects. `SymPy` uses the `SymMatrix` type as a proxy for
this class. However, most matrices are converted into `julia` arrays
of symbolic objects (`Array{Sym}`). This allows `julia` to handle many
of the common matrix operations, such as addition, subtraction ... It
also means there are extra conversions going on that may slow things
down a bit. It is hoped this tradeoff is worth it.

### Construction

Matrices can be constructed as usual just by using a symbolic object:

```
x, y = symbols("x y")
m = [x 1; 1 x]
```

The basic matrix arithmetic should work:

```
m * m
m .* m
```

Indexing should be fine:
```
m[1,2] = 2
```

Some basic functions work directly with the symbolic values:

```
trace(m)
det(m)
inv(m)
eigvals(m)
eigvecs(m)
dot(m, [1, x])
```

There are many other matrix functions provided by SymPy. Many are provided as methods. For example:

```
jordan_form(m)
```


text:
package gobblin.metrics;

import com.codahale.metrics.Counter;
import com.codahale.metrics.Histogram;
import com.codahale.metrics.Meter;
import com.codahale.metrics.MetricRegistry;
import java.io.ByteArrayOutputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

@Test(groups = {"gobblin.metrics"})
public class OutputStreamReporterTest {

  private ByteArrayOutputStream stream = new ByteArrayOutputStream();

  @Test
  public void testReporter() {

    MetricRegistry registry = new MetricRegistry();
    Counter counter = registry.counter("com.linkedin.example.counter");
    Meter meter = registry.meter("com.linkedin.example.meter");
    Histogram histogram = registry.histogram("com.linkedin.example.histogram");

    OutputStreamReporter reporter = OutputStreamReporter.
        forRegistry(registry).
        outputTo(stream).
        build();

    counter.inc();
    meter.mark(2);
    histogram.update(1);
    histogram.update(1);
    histogram.update(2);

    reporter.report();

    String[] lines = stream.toString().split("\n");

    Map<String, Set<String>> expected = new HashMap<String, Set<String>>();
    Set<String> counterSubMetrics = new HashSet<String>();
    counterSubMetrics.add("count");
    expected.put("com.linkedin.example.counter", counterSubMetrics);
    Set<String> histogramSubMetrics = new HashSet<String>();
    histogramSubMetrics.add("count");
    histogramSubMetrics.add("min");
    histogramSubMetrics.add("max");
    histogramSubMetrics.add("mean");
    histogramSubMetrics.add("stddev");
    histogramSubMetrics.add("median");
    histogramSubMetrics.add("75% <");
    histogramSubMetrics.add("95% <");
    expected.put("com.linkedin.example.histogram", histogramSubMetrics);
    Set<String> meterSubmetrics = new HashSet<String>();
    meterSubmetrics.add("count");
    meterSubmetrics.add("mean rate");
    meterSubmetrics.add("1-minute rate");
    meterSubmetrics.add("5-minute rate");
    meterSubmetrics.add("15-minute rate");
    expected.put("com.linkedin.example.meter", meterSubmetrics);

    expectMetrics(expected, lines);

    reporter.close();

  }

  @Test
  public void testTags() {
    MetricRegistry registry = new MetricRegistry();
    Counter counter = registry.counter("com.linkedin.example.counter");

    Map<String, String> tags = new HashMap<String, String>();
    tags.put("testKey", "testValue");
    tags.put("key2", "value2");

    OutputStreamReporter reporter = OutputStreamReporter.
        forRegistry(registry).
        withTags(tags).
        outputTo(stream).
        build();

    counter.inc();

    reporter.report();
    Assert.assertTrue(stream.toString().contains("key2=value2"));
    Assert.assertTrue(stream.toString().contains("testKey=testValue"));
    String[] lines = stream.toString().split("\n");

    Map<String, Set<String>> expected = new HashMap<String, Set<String>>();

    expectMetrics(expected, lines);
    Set<String> counterSubMetrics = new HashSet<String>();
    counterSubMetrics.add("count");
    expected.put("com.linkedin.example.counter", counterSubMetrics);

    reporter.close();

  }

  @Test
  public void testTagsFromContext() {
    Tag<?> tag1 = new Tag<String>("tag1", "value1");
    MetricContext context = MetricContext.builder("context").addTag(tag1).build();
    Counter counter = context.counter("com.linkedin.example.counter");

    OutputStreamReporter reporter = OutputStreamReporter.
        forContext(context).
        outputTo(stream).
        build();

    counter.inc();

    reporter.report();
    Assert.assertTrue(stream.toString().contains("tag1=value1"));
    String[] lines = stream.toString().split("\n");

    Map<String, Set<String>> expected = new HashMap<String, Set<String>>();

    expectMetrics(expected, lines);
    Set<String> counterSubMetrics = new HashSet<String>();
    counterSubMetrics.add("count");
    expected.put("com.linkedin.example.counter", counterSubMetrics);

    reporter.close();

  }

  @BeforeMethod
  public void before() {
    stream.reset();
  }

  private void expectMetrics(Map<String, Set<String>> metrics, String[] lines) {

    Set<String> activeSet = new HashSet<String>();
    String activeTopLevel = "";

    for (String line : lines) {
      System.out.println(line);
      if(line.contains("com.linkedin.example")) {
        Assert.assertTrue(activeSet.isEmpty(),
            String.format("%s does not contain all expected submetrics. Missing: %s",
                activeTopLevel, Arrays.toString(activeSet.toArray())));
        activeTopLevel = line.trim();
        if (metrics.containsKey(activeTopLevel)) {
          activeSet = metrics.get(activeTopLevel);
          metrics.remove(activeTopLevel);
        } else {
          activeSet = new HashSet<String>();
        }
      } else if (line.contains("=")) {
        String submetric = line.split("=")[0].trim();
        activeSet.remove(submetric);
      }
    }

    Assert.assertTrue(activeSet.isEmpty(),
        String.format("%s does not contain all expected submetrics. Missing: %s", activeTopLevel,
            Arrays.toString(activeSet.toArray())));
    Assert.assertTrue(metrics.isEmpty(),
        String.format("Output does not contain all expected top level metrics. Missing: %s",
            Arrays.toString(metrics.keySet().toArray())));

  }

}

redpajama_set_name: RedPajamaGithub


text:
@implementation MLDAnimations

+ (void)topSpringAnimation:(UIView *)animationView
             withSuperView:(UIView *)superView
{
    CGFloat toValue = superView.bounds.size.height + 10;
    POPSpringAnimation *springAnimation = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerPosition];
    CGPoint point = animationView.center;
    springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(point.x, point.y - toValue)];
    //弹性值
    springAnimation.springBounciness = 10;
    //弹性速度
    springAnimation.springSpeed = 60;
    [animationView pop_addAnimation:springAnimation forKey:@"topSpringAnimation"];
}

+ (void)bottomSpringAnimation:(UIView *)animationView
                withSuperView:(UIView *)superView
{
    CGFloat toValue = superView.bounds.size.height + 10;
    POPSpringAnimation *springAnimation = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerPosition];
    CGPoint point = animationView.center;
    springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(point.x, point.y + toValue)];
    //弹性值
    springAnimation.springBounciness = 10;
    //弹性速度
    springAnimation.springSpeed = 60;
    [animationView pop_addAnimation:springAnimation forKey:@"bottomSpringAnimation"];
}

+ (void)leftSpringAnimation:(UIView *)animationView
              withSuperView:(UIView *)superView
{
    CGFloat toValue = superView.bounds.size.width + 10;
    POPSpringAnimation *springAnimation = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerPosition];
    CGPoint point = animationView.center;
    springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(point.x - toValue, point.y)];
    //弹性值
    springAnimation.springBounciness = 10;
    //弹性速度
    springAnimation.springSpeed = 60;
    [animationView pop_addAnimation:springAnimation forKey:@"leftSpringAnimation"];
}

+ (void)leftTopSpringAnimation:(UIView *)animationView
                    withSuperView:(UIView *)superView
{
    CGFloat toValueH = superView.bounds.size.height + 10;
    CGFloat toValueW = superView.bounds.size.width + 10;
    POPSpringAnimation *springAnimation = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerPosition];
    CGPoint point = animationView.center;
    springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(point.x - toValueW, point.y - toValueH)];
    //弹性值
    springAnimation.springBounciness = 10;
    //弹性速度
    springAnimation.springSpeed = 60;
    [animationView pop_addAnimation:springAnimation forKey:@"leftTopSpringAnimation"];
}

+ (void)leftBottomSpringAnimation:(UIView *)animationView
                withSuperView:(UIView *)superView
{
    CGFloat toValueH = superView.bounds.size.height + 10;
    CGFloat toValueW = superView.bounds.size.width + 10;
    POPSpringAnimation *springAnimation = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerPosition];
    CGPoint point = animationView.center;
    springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(point.x - toValueW, point.y + toValueH)];
    //弹性值
    springAnimation.springBounciness = 10;
    //弹性速度
    springAnimation.springSpeed = 60;
    [animationView pop_addAnimation:springAnimation forKey:@"leftBottomSpringAnimation"];
}

+ (void)rightSpringAnimation:(UIView *)animationView
              withSuperView:(UIView *)superView
{
    CGFloat toValue = superView.bounds.size.width + 10;
    POPSpringAnimation *springAnimation = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerPosition];
    CGPoint point = animationView.center;
    springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(point.x + toValue, point.y)];
    //弹性值
    springAnimation.springBounciness = 10;
    //弹性速度
    springAnimation.springSpeed = 60;
    [animationView pop_addAnimation:springAnimation forKey:@"rightSpringAnimation"];
}

+ (void)rightTopSpringAnimation:(UIView *)animationView
                 withSuperView:(UIView *)superView
{
    CGFloat toValueH = superView.bounds.size.height + 10;
    CGFloat toValueW = superView.bounds.size.width + 10;
    POPSpringAnimation *springAnimation = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerPosition];
    CGPoint point = animationView.center;
    springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(point.x + toValueW, point.y - toValueH)];
    //弹性值
    springAnimation.springBounciness = 10;
    //弹性速度
    springAnimation.springSpeed = 60;
    [animationView pop_addAnimation:springAnimation forKey:@"rightTopSpringAnimation"];
}

+ (void)rightBottomSpringAnimation:(UIView *)animationView
                    withSuperView:(UIView *)superView
{
    CGFloat toValueH = superView.bounds.size.height + 10;
    CGFloat toValueW = superView.bounds.size.width + 10;
    POPSpringAnimation *springAnimation = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerPosition];
    CGPoint point = animationView.center;
    springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(point.x + toValueW, point.y + toValueH)];
    //弹性值
    springAnimation.springBounciness = 10;
    //弹性速度
    springAnimation.springSpeed = 60;
    [animationView pop_addAnimation:springAnimation forKey:@"rightBottomSpringAnimation"];
}

+ (void)backSpringAnimation:(UIView *)animationView
              withSuperView:(UIView *)superView
{
    POPSpringAnimation *springAnimation = [POPSpringAnimation animationWithPropertyNamed:kPOPLayerPosition];
    springAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(superView.center.x, superView.center.y)];
    //弹性值
    springAnimation.springBounciness = 10;
    //弹性速度
    springAnimation.springSpeed = 60;
    [animationView pop_addAnimation:springAnimation forKey:@"backSpringAnimation"];
}

@end


text:
'use strict';

var _ = require('underscore');

function unflatten(array, parent, tree) {
  tree = typeof tree !== 'undefined' ? tree : [];
  parent = typeof parent !== 'undefined' ? parent : { id: 0 };
  // jshint -W116
  var children = _.filter(array, function(child) {
    return child.masterSubnetId == parent.id; });
  if (!_.isEmpty(children)) {
    if (parent.id == 0) tree = children;
    else parent['subnets'] = children; // jscs:ignore requireDotNotation
    _.each(children, function(child) {
      unflatten(array, child);
    });
  }
  // jshint +W116
  return tree;
}

module.exports = unflatten;


text:
namespace Thriot.Client.DotNet.Reporting
{
    /// <summary>
    /// Latest telemetry data for a given device
    /// </summary>
    public class CurrentDataDeviceDto
    {
        /// <summary>
        /// Unique identifier of the device
        /// </summary>
        public string DeviceId { get; set; }

        /// <summary>
        /// Name of the device
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// UNIX timestamp of the latest data recording (elapsed seconds since 1970.1.1)
        /// </summary>
        public long Timestamp { get; set; }

        /// <summary>
        /// Latest payload
        /// </summary>
        public string Payload { get; set; }
    }
}


text:
package com.playersun.jbf.modules.sys.exception;

public class UserNameOrPasswordNotMatchException {

}


text:
    {{ byLabel(sorting.sortBy) }}

      {{ name }}


text:
{% load i18n staticfiles %}{% spaceless %}
{% if object %}
    {% trans 'Folder' %}: {{ object.pretty_logical_path }}
{% else %}
    {% trans 'Folder' %}: {% trans 'none selected' %}
{% endif %}

{{ hidden_input }}

{% endspaceless %}


text:
This is a node.js command line utility that will speed up your development process by 4x.

## Design and inspiration

Inspired by the great SlexAxton: https://twitter.com/SlexAxton/status/582763934379220992

**Features:**

* Fantastic ease and Beautiful UTF-8 characters.
* Responsive and retina-ready.
* Easy to install and use.

## Installation

This utility is available on npm, so installation is a breeze. Use the **-g** flag:

```bash
npm install -g idk
```

## Usage

To use it while working on a hot new flavascript application, run `idk`.

### Examples

```bash
idk
```

## Tests

Sorry there are no tests.

## Demo

![Demo](https://cloud.githubusercontent.com/assets/955736/6934646/bedb1e60-d7ec-11e4-9796-8edec8be35ce.gif)


text:
var RestOAuthBasePerm = require('./oAuthBasePerm.js').RestOAuthBasePerm;
var util = require("util");

var models = require('../../models');

function RestEventWriteGroup (server) {
	this._urlPrefix = '/perms/event/wg';

	RestOAuthBasePerm.call(this, 'event-write-group', models.perms.EventWriteGroup, server);

	this._initServer();

}
util.inherits(RestEventWriteGroup, RestOAuthBasePerm);

exports.RestEventWriteGroup = RestEventWriteGroup


text:
using namespace seqan;
using namespace std;

int main(int argc, char const ** argv) {
	String<PerformanceSample> performance;

	MemorySample ms("gesamt");
	ms.printToStdout();

	int res = clusterSearch(performance, argc, argv);
	ms.computeMemory();

	for (int i=0; i<length(performance);++i) {
		performance[i].printToStdout;
	}
	ms.printToStdout;
	return res;
}


text:
/*jslint browser:true, nomen:true, vars:true, plusplus:true*/
/*global define*/

define(function (require, exports, module) {
    'use strict';

    // import dependencies
    var Modifier = require('famous/core/Modifier');
    var RenderNode = require('famous/core/RenderNode');
    var Surface = require('famous/core/Surface');
    var Transform = require('famous/core/Transform');
    var View = require('famous/core/View');

    var StateModifier = require('famous/modifiers/StateModifier');
    var Easing = require('famous/transitions/Easing');
    var Transitionable = require('famous/transitions/Transitionable');
    var GridLayout = require('famous/views/GridLayout');
    var RenderController = require('famous/views/RenderController');

    /**
     * AppView
     * @class AppView
     * @extends View
     * @constructor
     * @param {Object} [options] Configuration options
     */
    function AppView(options) {
        View.apply(this, arguments);

        // Init
        this.transitionable = new Transitionable(0);
        this.modifier = new StateModifier();
        this.renderable = this.add(this.modifier);

        // Create rows
        this._createRows();
        this._createCounter();
        this._createEndScreen();

        // Reset
        this.reset();
    }
    AppView.prototype = Object.create(View.prototype);
    AppView.prototype.constructor = AppView;

    AppView.DEFAULT_OPTIONS = {
        rows: 4,
        cells: 4,
        godMode: false // basically, you never die when you enable this ;)
    };

    /**
     * @method _createRows
     */
    AppView.prototype._createRows = function () {
        this.rows = [];
        var i, j;
        for (i = 0; i <= this.options.rows; i++) {
            var row = {
                modifier: new Modifier({
                    size: [undefined, undefined]
                }),
                grid: new GridLayout({
                    dimensions: [this.options.cells, 1]
                }),
                cells: [],
                blackTile: -1,
                clickedTile: -1
            };
            var renderables = [];
            for (j = 0; j < this.options.cells; j++) {
                var cell = {
                    modifier: new StateModifier({
                        size: [undefined, undefined]
                    }),
                    surface: new Surface({
                        classes: ['cell']
                    })
                };
                cell.renderable = new RenderNode(cell.modifier);
                cell.renderable.add(cell.surface);
                cell.surface.on('mousedown', this._onClickCell.bind(this, i, j));
                cell.surface.on('touchstart', this._onClickCell.bind(this, i, j));
                row.cells.push(cell);
                renderables.push(cell.renderable);
            }
            row.grid.sequenceFrom(renderables);
            this.renderable.add(row.modifier).add(row.grid);
            this.rows.push(row);
        }
    };

    /**
     * @method _createCounter
     */
    AppView.prototype._createCounter = function () {
        this.counter = {
            score: 0,
            modifier: new Modifier({
                size: [70, 65],
                origin: [0.5, 0],
                align: [0.5, 0],
                transform: Transform.translate(0, 10, 0)
            }),
            surface: new Surface({
                classes: ['counter']
            })
        };
        this.renderable.add(this.counter.modifier).add(this.counter.surface);
    };

    /**
     * @method _createEndScreen
     */
    AppView.prototype._createEndScreen = function () {
        this.end = {
            renderController: new RenderController(),
            modifier: new Modifier(),
            backSurface: new Surface({
                classes: ['end']
            }),
            restartModifier: new Modifier({
                size: [undefined, 60],
                align: [0.5, 0.5],
                origin: [0.5, 0.5]
            }),
            restartSurface: new Surface({
                classes: ['end-button', 'restart'],
                content: 'Restart'
            }),
            scoreModifier: new Modifier({
                size: [undefined, 200],
                align: [0.5, 0.3],
                origin: [0.5, 0.3]
            }),
            scoreSurface: new Surface({
                classes: ['end-button', 'score'],
                content: 'Score'
            }),
            footerModifier: new Modifier({
                size: [undefined, 30],
                align: [1.0, 1.0],
                origin: [1.0, 1.0]
            }),
            footerSurface: new Surface({
                classes: ['end-button', 'footer'],
                content: '© 2014 - IjzerenHein'
            })
        };
        this.end.renderable = new RenderNode(this.end.modifier);
        this.end.renderable.add(this.end.backSurface);
        this.end.renderable.add(this.end.restartModifier).add(this.end.restartSurface);
        this.end.restartSurface.on('click', this.restart.bind(this));
        this.end.renderable.add(this.end.scoreModifier).add(this.end.scoreSurface);
        this.end.renderable.add(this.end.footerModifier).add(this.end.footerSurface);
        this.renderable.add(this.end.renderController);
    };

    /**
     * @method reset
     */
    AppView.prototype.reset = function () {
        var i, j;

        // Reset state
        this.transitionable.reset(0);
        this._isRunning = false;
        this._isStopped = false;

        // Reset rows
        for (i = 0; i < this.rows.length; i++) {
            var row = this.rows[i];
            row.blackTile = -1;
            row.clickedTile = -1;
            for (j = 0; j < row.cells.length; j++) {
                var cell = row.cells[j];
                cell.surface.setClasses(['cell']);
            }
        }

        // Generate start tiles
        this.blackTiles = [{black: -2, clicked: -1}]; // first line is yellow
        for (i = 0; i < 10; i++) {
            this._getTile(i);
        }

        // Set 'start' in first black tile
        this.rows[1].cells[this._getTile(1).black].surface.setContent('
Start
');

        // Reset counter
        this.counter.score = 0;
        this.counter.surface.setContent('
' + this.counter.score + '
');

        // Show playing field
        this.modifier.setTransform(Transform.translate(0, -window.innerHeight, 0));
        this.modifier.setTransform(
            Transform.translate(0, 0, 0),
            {duration: 300, curve: Easing.outBack}
        );
    };

    /**
     * @method restart
     */
    AppView.prototype.restart = function () {
        this.end.renderController.hide();
        this.reset();
    };

    /**
     * @method showEnd
     */
    AppView.prototype.showEnd = function () {
        this.end.scoreSurface.setContent(this.counter.score);
        this.end.renderController.show(this.end.renderable);
    };

    /**
     * @method _getTile
     */
    AppView.prototype._getTile = function (index) {
        var i;
        for (i = this.blackTiles.length; i <= index; i++) {
            var tile = {
                black: Math.floor(Math.random() * this.options.cells),
                clicked: -1
            };
            this.blackTiles.push(tile);
        }
        return this.blackTiles[index];
    };

    /**
     * @method _onClickCell
     */
    AppView.prototype._onClickCell = function (rowIndex, cellIndex, event) {

        event.preventDefault();

        // Ignore cell-clicks when stopped
        if (this._isStopped) {
            return;
        }

        // Get the clicked tile
        var offset = Math.floor(this.transitionable.get());
        var add = this.rows.length - (rowIndex + 1);
        var tileIndex = (offset + (this.rows.length - ((offset + add) % this.rows.length))) - 1;
        var tile = this._getTile(tileIndex);

        // Wait for player to click 'start'
        if (!this._isRunning) {

            // When not running, start when the start-tile is clicked
            if ((tileIndex === 1) && (cellIndex === this._getTile(tileIndex).black)) {
                tile.clicked = cellIndex;
                this.rows[rowIndex].cells[this._getTile(tileIndex).black].surface.setContent('');
                this.start();

                // Increase counter
                this.counter.score += 1;
                this.counter.surface.setContent('
' + this.counter.score + '
');
            }
            return;
        }

        // Stop the game when a white cell was pressed
        if (!this.options.godMode && (tile.black !== cellIndex)) {
            this.stop();
            var cell = this.rows[rowIndex].cells[cellIndex];
            cell.surface.addClass('fault');
            var blink = {duration: 200};
            var i;
            for (i = 0; i < 5; i++) {
                cell.modifier.setOpacity(0, blink);
                cell.modifier.setOpacity(1, blink);
            }
            cell.modifier.setOpacity(0, blink);
            cell.modifier.setOpacity(1, blink, this.showEnd.bind(this));
            return;
        }

        // Ingore clicks on black-tiles if the previous tile is not already black
        var prevTile = this._getTile(tileIndex - 1);
        if (!this.options.godMode && (prevTile.clicked < 0)) {
            return;
        }

        // Store click
        tile.clicked = cellIndex;

        // Increase counter
        this.counter.score += 1;
        this.counter.surface.setContent('
' + this.counter.score + '
');
    };

    /**
     * @method start
     */
    AppView.prototype.start = function () {
        this.state = {
            count: 0,
            increment: 10,
            duration: 5000
        };
        this.transitionable.set(
            this.state.count + this.state.increment,
            {duration: this.state.duration},
            this.speedup.bind(this)
        );
        this._isRunning = true;
    };

    /**
     * @method speedup
     */
    AppView.prototype.speedup = function () {
        this.state.count += this.state.increment;
        this.state.duration = this.state.duration * 0.9;
        this.transitionable.set(
            this.state.count + this.state.increment,
            {duration: this.state.duration},
            this.speedup.bind(this)
        );
    };

    /**
     * @method stop
     */
    AppView.prototype.stop = function () {
        this.transitionable.halt();
        this._isRunning = false;
        this._isStopped = true;
    };

    /**
     * Renders the view.
     *
     * @method render
     * @private
     * @ignore
     */
    AppView.prototype.render = function render() {

        // Calculate stuff
        var rowHeight = window.innerHeight / this.options.rows;
        var i, j, y = 0;
        var rawOffset = this.transitionable.get();
        var offset = Math.floor(rawOffset);
        var start = offset % this.rows.length;

        // Determine offset of bottom row
        var fraction = (rawOffset % 1) * rowHeight;
        y = ((window.innerHeight + fraction) - rowHeight);

        // Update rows
        for (i = 0; i < this.rows.length; i++) {
            var rowIndex = (i + start) % this.rows.length;
            var row = this.rows[rowIndex];

            // Set tile-color
            var tile = this._getTile(offset + i);
            if (row.blackTile !== tile.black) {
                if (row.blackTile >= 0) {
                    row.cells[row.blackTile].surface.removeClass('black');
                } else if (row.blackTile === -2) {
                    for (j = 0; j < row.cells.length; j++) {
                        row.cells[j].surface.removeClass('yellow');
                    }
                }
                if (tile.black === -2) {
                    for (j = 0; j < row.cells.length; j++) {
                        row.cells[j].surface.addClass('yellow');
                    }
                } else if (tile.black !== -1) {
                    row.cells[tile.black].surface.addClass('black');
                }
                row.blackTile = tile.black;
            }

            // Set clicked color
            if (row.clickedTile !== tile.clicked) {
                if (row.clickedTile >= 0) {
                    row.cells[row.clickedTile].surface.removeClass('clicked');
                }
                if (tile.clicked >= 0) {
                    row.cells[tile.clicked].surface.addClass('clicked');
                }
                row.clickedTile = tile.clicked;
            }

            // Positions the row
            row.modifier.sizeFrom([undefined, rowHeight]);
            row.modifier.transformFrom(
                Transform.translate(0, y, 0)
            );
            y -= rowHeight;
        }

        // Check if the player missed the tile
        if (this._isRunning && !this.options.godMode && (offset > 1)) {
            var prevTile = this._getTile(offset - 1);
            if (prevTile.clicked < 0) {
                this.stop();
                this.transitionable.set(
                    offset - 2,
                    { duration: 500, curve: Easing.outBack }
                );
                var cell = this.rows[(offset - 1) % this.rows.length].cells[prevTile.black];
                cell.surface.addClass('missed');
                var blink = {duration: 200};
                for (i = 0; i < 5; i++) {
                    cell.modifier.setOpacity(0, blink);
                    cell.modifier.setOpacity(1, blink);
                }
                cell.modifier.setOpacity(0, blink);
                cell.modifier.setOpacity(1, blink, this.showEnd.bind(this));
            }
        }

        // Call super
        return this._node.render();
    };

    module.exports = AppView;
});


text:
import React from 'react';
import PropTypes from 'prop-types';

export const Text = (props) => {
  const {
    type,
    style,
    placeholder,
    fieldDefinition,
  } = props;

  return (
    <input
      className="block col-12 mb1 field"
      style={{ ...styles.base, ...style }}
      type={ type }
      placeholder={ placeholder }
      { ...fieldDefinition } />
  );
};

const styles = {
  base: {},
};

Text.propTypes = {
  type: PropTypes.string,
  style: PropTypes.object,
  placeholder: PropTypes.string,
  fieldDefinition: PropTypes.object.isRequired,
};

Text.defaultProps = {
  type: 'preview',
  style: {},
  placeholder: '',
};


text:
sudo rmmod write_msr
sudo rmmod enable_user_pmc


text:
package ingredientes;

public class QueijoMussarela implements Queijo{

	@Override
	public String getDescricao() {
		return "queijo mussarela";
	}

}


text:
package net.digitalid.utility.validation.validators;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.type.TypeMirror;

import net.digitalid.utility.annotations.method.Pure;
import net.digitalid.utility.annotations.ownership.NonCaptured;
import net.digitalid.utility.annotations.parameter.Modified;
import net.digitalid.utility.annotations.parameter.Unmodified;
import net.digitalid.utility.processing.logging.ErrorLogger;
import net.digitalid.utility.processing.logging.SourcePosition;
import net.digitalid.utility.processing.utility.ProcessingUtility;
import net.digitalid.utility.processing.utility.TypeImporter;
import net.digitalid.utility.validation.annotations.elements.NullableElements;
import net.digitalid.utility.validation.annotations.type.Stateless;
import net.digitalid.utility.validation.contract.Contract;

/**
 * This class implements common methods for all ordering-related validators.
 *
 * @see net.digitalid.utility.validation.annotations.order
 */
@Stateless
public abstract class OrderingValidator extends IterableValidator {

    /* -------------------------------------------------- Usage Check -------------------------------------------------- */

    @Pure
    @Override
    public void checkUsage(@Nonnull Element element, @Nonnull AnnotationMirror annotationMirror, @NonCaptured @Modified @Nonnull ErrorLogger errorLogger) {
        super.checkUsage(element, annotationMirror, errorLogger);

        final @Nullable TypeMirror componentType = ProcessingUtility.getComponentType(element, errorLogger);
        if (componentType != null && !componentType.getKind().isPrimitive() && !ProcessingUtility.isRawSubtype(componentType, Comparable.class)) {
            errorLogger.log("The annotation $ may only be used on arrays and iterables whose component type is comparable, which is not the case for $:", SourcePosition.of(element, annotationMirror), getAnnotationNameWithLeadingAt(), componentType);
        }
    }

    /* -------------------------------------------------- Validation -------------------------------------------------- */

    /**
     * Returns whether the elements in the given iterable are ordered (excluding null values).
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the elements in the iterable are ordered, {@code false} otherwise.
     */
    @Pure
    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> boolean validate(@NonCaptured @Unmodified @Nullable Iterable<@Nullable T> iterable, boolean strictly, boolean ascending) {
        if (iterable == null) { return true; }
        @Nullable T lastElement = null;
        for (@Nullable T element : iterable) {
            if (element != null) {
                if (lastElement != null) {
                    if (element.compareTo(lastElement) * (ascending ? 1 : -1) < (strictly ? 1 : 0)) { return false; }
                }
                lastElement = element;
            }
        }
        return true;
    }

    /**
     * Returns whether the elements in the given array are ordered (excluding null values).
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the elements in the array are ordered, {@code false} otherwise.
     */
    @Pure
    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> boolean validate(@NonCaptured @Unmodified @Nullable @NullableElements T[] array, boolean strictly, boolean ascending) {
        if (array == null) { return true; }
        @Nullable T lastElement = null;
        for (@Nullable T element : array) {
            if (element != null) {
                if (lastElement != null) {
                    if (element.compareTo(lastElement) * (ascending ? 1 : -1) < (strictly ? 1 : 0)) { return false; }
                }
                lastElement = element;
            }
        }
        return true;
    }

    /**
     * Returns whether the values in the given array are ordered.
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the values in the array are ordered, {@code false} otherwise.
     */
    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable boolean[] array, boolean strictly, boolean ascending) {
        if (array == null || array.length < 2) { return true; }
        else if (strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1]) { return false; } } }
        else if (!strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] && !array[i]) { return false; } } }
        else if (strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(!array[i - 1]) { return false; } } }
        else if (!strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(!array[i - 1] && array[i]) { return false; } } }
        return true;
    }

    /**
     * Returns whether the values in the given array are ordered.
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the values in the array are ordered, {@code false} otherwise.
     */
    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable char[] array, boolean strictly, boolean ascending) {
        if (array == null || array.length < 2) { return true; }
        else if (strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] >= array[i]) { return false; } } }
        else if (!strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] > array[i]) { return false; } } }
        else if (strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] <= array[i]) { return false; } } }
        else if (!strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] < array[i]) { return false; } } }
        return true;
    }

    /**
     * Returns whether the values in the given array are ordered.
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the values in the array are ordered, {@code false} otherwise.
     */
    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable byte[] array, boolean strictly, boolean ascending) {
        if (array == null || array.length < 2) { return true; }
        else if (strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] >= array[i]) { return false; } } }
        else if (!strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] > array[i]) { return false; } } }
        else if (strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] <= array[i]) { return false; } } }
        else if (!strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] < array[i]) { return false; } } }
        return true;
    }

    /**
     * Returns whether the values in the given array are ordered.
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the values in the array are ordered, {@code false} otherwise.
     */
    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable short[] array, boolean strictly, boolean ascending) {
        if (array == null || array.length < 2) { return true; }
        else if (strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] >= array[i]) { return false; } } }
        else if (!strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] > array[i]) { return false; } } }
        else if (strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] <= array[i]) { return false; } } }
        else if (!strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] < array[i]) { return false; } } }
        return true;
    }

    /**
     * Returns whether the values in the given array are ordered.
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the values in the array are ordered, {@code false} otherwise.
     */
    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable int[] array, boolean strictly, boolean ascending) {
        if (array == null || array.length < 2) { return true; }
        else if (strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] >= array[i]) { return false; } } }
        else if (!strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] > array[i]) { return false; } } }
        else if (strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] <= array[i]) { return false; } } }
        else if (!strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] < array[i]) { return false; } } }
        return true;
    }

    /**
     * Returns whether the values in the given array are ordered.
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the values in the array are ordered, {@code false} otherwise.
     */
    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable long[] array, boolean strictly, boolean ascending) {
        if (array == null || array.length < 2) { return true; }
        else if (strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] >= array[i]) { return false; } } }
        else if (!strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] > array[i]) { return false; } } }
        else if (strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] <= array[i]) { return false; } } }
        else if (!strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] < array[i]) { return false; } } }
        return true;
    }

    /**
     * Returns whether the values in the given array are ordered.
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the values in the array are ordered, {@code false} otherwise.
     */
    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable float[] array, boolean strictly, boolean ascending) {
        if (array == null || array.length < 2) { return true; }
        else if (strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] >= array[i]) { return false; } } }
        else if (!strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] > array[i]) { return false; } } }
        else if (strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] <= array[i]) { return false; } } }
        else if (!strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] < array[i]) { return false; } } }
        return true;
    }

    /**
     * Returns whether the values in the given array are ordered.
     *
     * @param strictly whether the ordering is strict (i.e. without equal values).
     * @param ascending whether the ordering is ascending (true) or descending (false).
     *
     * @return {@code true} if the values in the array are ordered, {@code false} otherwise.
     */
    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable double[] array, boolean strictly, boolean ascending) {
        if (array == null || array.length < 2) { return true; }
        else if (strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] >= array[i]) { return false; } } }
        else if (!strictly && ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] > array[i]) { return false; } } }
        else if (strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] <= array[i]) { return false; } } }
        else if (!strictly && !ascending) { for (int i = 1; i < array.length; i++) { if(array[i - 1] < array[i]) { return false; } } }
        return true;
    }

    /*

    // Other implementations for arrays with primitive component types are:

    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable int[] array, boolean strictly, boolean ascending) {
        if (array == null || array.length < 2) { return true; }
        int lastValue = array[0];
        final int factor = ascending ? 1 : -1;
        for (int i = 1; i < array.length; i++) {
            final int nextValue = array[i];
            if (lastValue * factor >= nextValue * factor && (strictly || lastValue != nextValue)) { return false; }
            lastValue = nextValue;
        }
        return true;
    }

    @Pure
    public static boolean validate(@NonCaptured @Unmodified @Nullable int[] array, boolean strictly, boolean ascending) {
        if (array == null) { return true; }
        for (int i = 1; i < array.length; i++) {
            if (array[i - 1] * (ascending ? 1 : -1) >= array[i] * (ascending ? 1 : -1) && (strictly || array[i - 1] != array[i])) { return false; }
        }
        return true;
    }

    */

    /* -------------------------------------------------- Abstract Methods -------------------------------------------------- */

    @Pure
    protected abstract boolean isStrictly();

    @Pure
    protected abstract boolean isAscending();

    /* -------------------------------------------------- Contract Generation -------------------------------------------------- */

    @Pure
    @Override
    public @Nonnull Contract generateContract(@Nonnull Element element, @Nonnull AnnotationMirror annotationMirror, @NonCaptured @Modified @Nonnull TypeImporter typeImporter) {
        return Contract.with(typeImporter.importIfPossible(OrderingValidator.class) + ".validate(#, " + isStrictly() + ", " + isAscending() + ")", "The # has to be ordered.", element);
    }

}


text:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- Context parameters -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/root-context.xml /WEB-INF/spring/security-context.xml</param-value>
    </context-param>
    <context-param>
        <param-name>org.apache.myfaces.STRICT_JSF_2_FACELETS_COMPATIBILITY</param-name>
        <param-value>true</param-value>
    </context-param>
    <context-param>
        <param-name>org.apache.myfaces.EXPRESSION_FACTORY</param-name>
        <param-value>com.sun.el.ExpressionFactoryImpl</param-value>
    </context-param>
    <context-param>
        <param-name>com.sun.faces.expressionFactory</param-name>
        <param-value>com.sun.el.ExpressionFactoryImpl</param-value>
    </context-param>
    <context-param>
        <param-name>javax.faces.FACELETS_SKIP_COMMENTS</param-name>
        <param-value>true</param-value>
    </context-param>
    <context-param>
        <param-name>javax.faces.DEFAULT_SUFFIX</param-name>
        <param-value>.xhtml</param-value>
    </context-param>
    <context-param>
        <param-name>javax.faces.PROJECT_STAGE</param-name>
        <param-value>Production</param-value>
    </context-param>
    <context-param>
        <param-name>javax.faces.FACELETS_DEVELOPMENT</param-name>
        <param-value>true</param-value>
    </context-param>
    <context-param>
        <param-name>javax.faces.FACELETS_REFRESH_PERIOD</param-name>
        <param-value>2</param-value>
    </context-param>
    <context-param>
        <param-name>primefaces.THEME</param-name>
        <param-value>aristo</param-value>
    </context-param>
    <context-param>
		<param-name>primefaces.UPLOADER</param-name>
		<param-value>commons</param-value>
	</context-param>
    <context-param>
		<param-name>primefaces.FONT_AWESOME</param-name>
		<param-value>true</param-value>
	</context-param>

    <!-- MIME mapping -->
    <mime-mapping>
        <extension>eot</extension>
        <mime-type>application/vnd.ms-fontobject</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>otf</extension>
        <mime-type>font/opentype</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>ttf</extension>
        <mime-type>application/x-font-ttf</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>woff</extension>
        <mime-type>application/x-font-woff</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>svg</extension>
        <mime-type>image/svg+xml</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>woff2</extension>
        <mime-type>application/x-font-woff2</mime-type>
    </mime-mapping>

	<!-- Enables PrimeFaces File Upload -->
	<filter>
		<filter-name>PrimeFaces FileUpload Filter</filter-name>
		<filter-class>org.primefaces.webapp.filter.FileUploadFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>PrimeFaces FileUpload Filter</filter-name>
		<servlet-name>appServlet</servlet-name>
	</filter-mapping>

    <!-- Enables Spring Security -->
    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>
            org.springframework.web.filter.DelegatingFilterProxy
        </filter-class>
    </filter>
    <filter-mapping>
	    <filter-name>springSecurityFilterChain</filter-name>
	    <url-pattern>/*</url-pattern>
	    <dispatcher>FORWARD</dispatcher>
        <dispatcher>REQUEST</dispatcher>
	</filter-mapping>

    <!-- CharacterEncodingFilter / UTF-8 -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
            <init-param>
                <param-name>encoding</param-name>
                <param-value>UTF-8</param-value>
            </init-param>
            <init-param>
                <param-name>forceEncoding</param-name>
                <param-value>true</param-value>
            </init-param>
    </filter>

    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.faces</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring/servlet-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>

    <session-config>
        <session-timeout>-1</session-timeout>
    </session-config>
</web-app>


text:
package org.jbpm.datamodeler.codegen.parser.tokens;

public class AnnotationValuePairToken extends Token {

    private String name;

    private String value;

    public static final String ANNOTATION_VALUE_PAIR_TOKEN = "ANNOTATION_VALUE_PAIR_TOKEN";

    public AnnotationValuePairToken() {
        super(ANNOTATION_VALUE_PAIR_TOKEN);
    }

    public AnnotationValuePairToken(String name, String value) {
        this();
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}


text: require "sendgrid_collins/api/api"


text:
layout: page_v2
page_type: module
title: Module - fledgeForGpt
description: how to use fledge with GPT
module_code : fledgeForGpt
display_name : Fledge for GPT
enable_download : true
sidebarType : 1
---

# Overview
This module allows Prebid.js to support FLEDGE by integrating it with GPT's [experimental FLEDGE
support](https://github.com/google/ads-privacy/tree/master/proposals/fledge-multiple-seller-testing).

To learn more about FLEDGE in general, go [here](https://github.com/WICG/turtledove/blob/main/FLEDGE.md).

This document covers the steps necessary for publishers to enable FLEDGE on their inventory. It also describes
the changes Bid Adapters need to implement in order to support FLEDGE.

## Publisher Integration
Publishers wishing to enable FLEDGE support must do two things. First, they must compile Prebid.js with support for this module.
This is accomplished by adding the `fledgeForGpt` module to the list of modules they are already using:

```
gulp build --modules=fledgeForGpt,...
```

Second, they must enable FLEDGE in their Prebid.js configuration. To provide a high degree of flexiblity for testing, FLEDGE
settings exist at the module level, the bidder level, and the adunit level.

### Module Configuration
This module exposes the following settings:

|Name |Type |Description |Notes |
| :------------ | :------------ | :------------ |:------------ |
|enabled | Boolean |Enable/disable the module |Defaults to `false` |

As noted above, FLEDGE support is disabled by default. To enable it, set the `enabled` value to `true` for this module
using the `setConfig` method of Prebid.js:

```js
pbjs.que.push(function() {
  pbjs.setConfig({
    fledgeForGpt: {
      enabled: true
    }
  });
});
```

### Bidder Configuration
This module adds the following setting for bidders:

|Name |Type |Description |Notes |
| :------------ | :------------ | :------------ |:------------ |
| fledgeEnabled | Boolean | Enable/disable a bidder to participate in FLEDGE | Defaults to `false` |

In addition to enabling FLEDGE at the module level, individual bidders must also be enabled. This allows publishers to
selectively test with one or more bidders as they desire. To enable one or more bidders, use the `setBidderConfig` method
of Prebid.js:

```js
pbjs.setBidderConfig({
    bidders: ["openx"],
    config: {
        fledgeEnabled: true
    }
});
```

### AdUnit Configuration
Enabling an adunit for FLEDGE eligibility is accomplished by setting an attribute of the `ortb2Imp` object for that
adunit.

|Name |Type |Description |Notes |
| :------------ | :------------ | :------------ |:------------ |
| ortb2Imp.ext.ae | Integer | Auction Environment: 1 indicates FLEDGE eligible, 0 indicates it is not | Absence indicates this is not FLEDGE eligible |

The `ae` field stands for Auction Environment and was chosen to be consistent with the field that GAM passes to bidders
in their Open Bidding and Exchange Bidding APIs. More details on that can be found
[here](https://github.com/google/ads-privacy/tree/master/proposals/fledge-rtb#bid-request-changes-indicating-interest-group-auction-support)
In practice, this looks as follows:

```js
pbjs.addAdUnits({
    code: "my-adunit-div",
    // other config here
    ortb2Imp: {
        ext: {
            ae: 1
        }
    }
});
```

## Bid Adapter Integration
Chrome has enabled a two-tier auction in FLEDGE. This allows multiple sellers (frequently SSPs) to act on behalf of the publisher with
a single entity serving as the final decision maker. In their [current approach](https://github.com/google/ads-privacy/tree/master/proposals/fledge-multiple-seller-testing),
GPT has opted to run the final auction layer while allowing other SSPs/sellers to participate as
[Component Auctions](https://github.com/WICG/turtledove/blob/main/FLEDGE.md#21-initiating-an-on-device-auction) which feed their
bids to the final layer. To learn more about Component Auctions, go [here](https://github.com/WICG/turtledove/blob/main/FLEDGE.md#24-scoring-bids-in-component-auctions).

The FLEDGE auction, including Component Auctions, are configured via an `AuctionConfig` object that defines the parameters of the auction for a given
seller. This module enables FLEDGE support by allowing bid adaptors to return `AuctionConfig` objects in addition to bids. If a bid adaptor returns an
`AuctionConfig` object, Prebid.js will register it with the appropriate GPT ad slot so the bidder can participate as a Component Auction in the overall
FLEDGE auction for that slot. More details on the GPT API can be found [here](https://developers.google.com/publisher-tag/reference#googletag.config.componentauctionconfig).

Modifying a bid adapter to support FLEDGE is a straightforward process and consists of the following steps:
1. Detecting when a bid request is FLEDGE eligible
2. Responding with AuctionConfig

FLEDGE eligibility is made available to bid adapters through the `bidderRequest.fledgeEnabled` field.
The [`bidderRequest`](/dev-docs/bidder-adaptor.html#bidderrequest-parameters) object is passed to
the [`buildRequests`](/dev-docs/bidder-adaptor.html#building-the-request) method of an adapter. Bid adapters
who wish to participate should read this flag and pass it to their server. FLEDGE eligibility depends on a number of parameters:

1. Chrome enablement
2. Publisher participatipon in the [Origin Trial](https://developer.chrome.com/docs/privacy-sandbox/unified-origin-trial/#configure)
3. Publisher Prebid.js configuration (detailed above)

When a bid request is FLEDGE enabled, a bid adapter can return a tuple consisting of bids and AuctionConfig objects rather than just a list of bids:

```js
function interpretResponse(resp, req) {
    // Load the bids from the response - this is adapter specific
    const bids = parseBids(resp);

    // Load the auctionConfigs from the response - also adapter specific
    const auctionConfigs = parseAuctionConfigs(resp);

    if (auctionConfigs) {
        // Return a tuple of bids and auctionConfigs. It is possible that bids could be null.
        return {bids, auctionConfigs};
    } else {
        return bids;
    }
}
```

An AuctionConfig must be associated with an adunit and auction, and this is accomplished using the value in the `bidId` field from the objects in the
`validBidRequests` array passed to the `buildRequests` function - see [here](/dev-docs/bidder-adaptor.html#ad-unit-params-in-the-validbidrequests-array)
for more details. This means that the AuctionConfig objects returned from `interpretResponse` must contain a `bidId` field whose value corresponds to
the request it should be associated with. This may raise the question: why isn't the AuctionConfig object returned as part of the bid? The
answer is that it's possible to participate in the FLEDGE auction without returning a contextual bid.

An example of this can be seen in the OpenX OpenRTB bid adapter [here](https://github.com/prebid/Prebid.js/blob/master/modules/openxOrtbBidAdapter.js#L327).

Other than the addition of the `bidId` field, the `AuctionConfig` object should adhere to the requirements set forth in FLEDGE. The details of creating an
`AuctionConfig` object are beyond the scope of this document.

## Related Reading
- [FLEDGE](https://github.com/WICG/turtledove/blob/main/FLEDGE.md)
- [Component Auctions](https://github.com/WICG/turtledove/blob/main/FLEDGE.md#21-initiating-an-on-device-auction)


text:
import { fakeAsync } from '@angular/core/testing';

import { DocumentInterruptSource } from './documentinterruptsource';

describe('core/DocumentInterruptSource', () => {
  it('emits onInterrupt event when attached and event is fired', fakeAsync(() => {
    const source = new DocumentInterruptSource('click');
    source.initialize();
    spyOn(source.onInterrupt, 'emit').and.callThrough();
    source.attach();

    const expected = new Event('click');
    document.documentElement.dispatchEvent(expected);

    expect(source.onInterrupt.emit).toHaveBeenCalledTimes(1);

    source.detach();
  }));

  it('does not emit events when running on a server', fakeAsync(() => {
    const source = new DocumentInterruptSource('click');
    const options = { platformId: 'server' as unknown as object };
    source.initialize(options);
    spyOn(source.onInterrupt, 'emit').and.callThrough();
    source.attach();

    const expected = new Event('click');
    document.documentElement.dispatchEvent(expected);

    expect(source.onInterrupt.emit).not.toHaveBeenCalled();

    source.detach();
  }));

  it('does not emit onInterrupt event when detached and event is fired', fakeAsync(() => {
    const source = new DocumentInterruptSource('click');
    source.initialize();
    spyOn(source.onInterrupt, 'emit').and.callThrough();

    // make it interesting by attaching and detaching
    source.attach();
    source.detach();

    const expected = new Event('click');
    document.documentElement.dispatchEvent(expected);

    expect(source.onInterrupt.emit).not.toHaveBeenCalled();
  }));

  it('should not emit onInterrupt event when Chrome desktop notifications are visible', fakeAsync(() => {
    const source = new DocumentInterruptSource('mousemove');
    source.initialize();
    spyOn(source.onInterrupt, 'emit').and.callThrough();
    source.attach();

    const expected: any = new Event('mousemove');
    expected.originalEvent = { movementX: 0, movementY: 0 };

    document.documentElement.dispatchEvent(expected);

    expect(source.onInterrupt.emit).not.toHaveBeenCalled();

    source.detach();
  }));

  it('should not emit onInterrupt event on webkit fake mousemove events', fakeAsync(() => {
    const source = new DocumentInterruptSource('mousemove');
    source.initialize();
    spyOn(source.onInterrupt, 'emit').and.callThrough();
    source.attach();

    const expected: any = new Event('mousemove');

    expected.movementX = 0;
    expected.movementY = 0;

    document.documentElement.dispatchEvent(expected);

    expect(source.onInterrupt.emit).not.toHaveBeenCalled();

    source.detach();
  }));

  it('should emit onInterrupt event on webkit real mousemove events', fakeAsync(() => {
    const source = new DocumentInterruptSource('mousemove');
    source.initialize();
    spyOn(source.onInterrupt, 'emit').and.callThrough();
    source.attach();

    const expected: any = new Event('mousemove');

    expected.movementX = 7;
    expected.movementY = 16;

    document.documentElement.dispatchEvent(expected);

    expect(source.onInterrupt.emit).toHaveBeenCalledTimes(1);

    source.detach();
  }));
});


text:
package cn.newcapec.function.platform.dao;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Repository;

import cn.newcapec.function.platform.dao.impl.BaseLegelPersonDao;
import cn.newcapec.framework.core.utils.pagesUtils.Page;

@SuppressWarnings("all")
@Repository("legelPersonDao")
public class LegelPersonDao extends BaseLegelPersonDao {

	public Page query(Map<String, Object> params, LinkedHashMap<String, String> orderby) {
		List<Object> param = new ArrayList<Object>();

		StringBuilder sql = new StringBuilder();
		sql.append("select ");
		sql.append("a.id, a.CustomerUnitCode, a.CustomerName, a.CustomerNameJP, a.LinkMan, a.Telephone, a.Address, a.Email, a.BankCode, a.BankCardNo, a.DataBaseStr, a.WebUrl, a.OpDt, a.OpenDt, a.Remark, a.Status, a.IsDelete, a.IsBalance");
		sql.append(", b.BankName");
		sql.append(" from BASE_LEGAL_PERSON a");
		sql.append(" Left JOIN BASE_BANK b on a.BANKCODE=b.ID");

		return this.sqlQueryForPage(sql.toString(), null, 0, 100, null);
	}
}


text:
{% extends "base.html" %}

{% block title %}New Profile{% endblock %}

{% block content %}
    <form action="/create/profile/" method='post'>

                Name*
                Age
                Gender
                Race
                Height
                Weight

                <input name="name" value="{{ name }}" size=14 />
                <input name="age" value="{{ age }}" size=4 />

                    <select name="gender" />
                        <option value=""></option>
                        <option value="Male">Male</option>
                        <option value="Female">Female</option>
                        <option value="Neither">Neither</option>
                    </select>

                <input name="race" value="{{ race }}" size=8 />
                <input name="height" value="{{ height }}" size=7 />
                <input name="weight" value="{{ weight }}" size=7 />

Appearance

<textarea name="apperence" rows="10" cols="40">{{ apperence }}</textarea>

Background

<textarea name="background" rows="10" cols="40">{{ background }}</textarea>

Extra Info

<textarea name="extra_info" rows="10" cols="40">{{ extra_info }}</textarea>

    <input type="submit" value="Submit" />

* indicates a required field

{% endblock %}

{% block sidebar_header %}

New Character

Here you can create a new character profile.

Markupable fields:  Appearance, Background, Extra Info, Links

Options

Private profiles cannot be seen by anyone but you.

<input type="radio" name="public" value="True" checked /> Public

<input type="radio" name="public" value="False" /> Private

Sybil will render the profile in the selected markup langauge.

<input type="radio" name="markup" value="PlainText" /> Plain Text

<input type="radio" name="markup" value="Textile" checked /> Textile

<input type="radio" name="markup" value="ReST" /> reStructuredText

Links

Content here is displayed in the sidebar.

<textarea name="links" rows="8" cols="40"></textarea>

Common Elements

Content here will be appended to the fields that accept markup.

                {#

Example (Textile)

In the input field:
"Python":python_link is great!

In the field below:
[python_link]http://www.python.org

                #}

<textarea name='common' rows="8" cols="40"></textarea>

    </form>
{% endblock %}


text:
FIND_PATH(SDL2_IMAGE_INCLUDE_DIR SDL_image.h
	HINTS
	$ENV{SDL2}
	$ENV{SDL2_IMAGE}
	PATH_SUFFIXES include/SDL2 include SDL2
	i686-w64-mingw32/include/SDL2
	x86_64-w64-mingw32/include/SDL2
	PATHS
	~/Library/Frameworks
	/Library/Frameworks
	/usr/local/include/SDL2
	/usr/include/SDL2
	/sw # Fink
	/opt/local # DarwinPorts
	/opt/csw # Blastwave
	/opt
)

# Lookup the 64 bit libs on x64
IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
	FIND_LIBRARY(SDL2_IMAGE_LIBRARY_TEMP
		NAMES SDL2_image
		HINTS
		$ENV{SDL2}
		$ENV{SDL2_IMAGE}
		PATH_SUFFIXES lib64 lib
		lib/x64
		x86_64-w64-mingw32/lib
		PATHS
		/sw
		/opt/local
		/opt/csw
		/opt
	)
# On 32bit build find the 32bit libs
ELSE(CMAKE_SIZEOF_VOID_P EQUAL 8)
	FIND_LIBRARY(SDL2_IMAGE_LIBRARY_TEMP
		NAMES SDL2_image
		HINTS
		$ENV{SDL2}
		$ENV{SDL2_IMAGE}
		PATH_SUFFIXES lib
		lib/x86
		i686-w64-mingw32/lib
		PATHS
		/sw
		/opt/local
		/opt/csw
		/opt
	)
ENDIF(CMAKE_SIZEOF_VOID_P EQUAL 8)

SET(SDL2_IMAGE_FOUND "NO")
	IF(SDL2_IMAGE_LIBRARY_TEMP)
	# Set the final string here so the GUI reflects the final state.
	SET(SDL2_IMAGE_LIBRARY ${SDL2_IMAGE_LIBRARY_TEMP} CACHE STRING "Where the SDL2_image Library can be found")
	# Set the temp variable to INTERNAL so it is not seen in the CMake GUI
	SET(SDL2_IMAGE_LIBRARY_TEMP "${SDL2_IMAGE_LIBRARY_TEMP}" CACHE INTERNAL "")
	SET(SDL2_IMAGE_FOUND "YES")
ENDIF(SDL2_IMAGE_LIBRARY_TEMP)

INCLUDE(FindPackageHandleStandardArgs)

FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2_IMAGE REQUIRED_VARS SDL2_IMAGE_LIBRARY SDL2_IMAGE_INCLUDE_DIR)


text:
<ion-side-menus enable-menu-with-back-views="false">
  <ion-side-menu-content>
    <ion-nav-bar class="bar-stable">
      <ion-nav-back-button>
      </ion-nav-back-button>

      <ion-nav-buttons side="left">
        <button class="button button-icon button-clear ion-navicon" menu-toggle="left">
        </button>
      </ion-nav-buttons>
    </ion-nav-bar>
    <ion-nav-view name="menuContent"></ion-nav-view>
  </ion-side-menu-content>

  <ion-side-menu side="left">
        <ion-header-bar class="bar-side">

Ana Todurie

        </ion-header-bar>
    <ion-content style="top:166px;">

          Home

          About

            Notification

          Contact

            Events

            Blog

            Photos

            Videos

            Logout

    </ion-content>
  </ion-side-menu>
</ion-side-menus>


text: Python Repo to test Travis CI Integration


text:
namespace arc {
namespace data_snapshotd {

// This class tracks installation of the list of ARC apps.
class ArcAppsTracker {
 public:
  // The destruction of the instance stops tracking installation of the list of
  // ARC apps and compliance with policy.
  virtual ~ArcAppsTracker() = default;

  // Starts tracking installation of the list of ARC apps.
  // Invokes a repeating callback |update_callback| when the number of installed
  // tracked apps changes. |update_callback| is invoked with the percent of
  // installed tracked apps in a range of 0..100.
  // Invokes a |finish_callback| once ARC is compliant with policy and the
  // apps tracking is finished.
  // |update_callback| is guaranteed to be never invoked after
  // |finish_callback|.
  virtual void StartTracking(base::RepeatingCallback<void(int)> update_callback,
                             base::OnceClosure finish_callback) = 0;
};

}  // namespace data_snapshotd
}  // namespace arc

#endif  // ASH_COMPONENTS_ARC_ENTERPRISE_ARC_APPS_TRACKER_H_