text:
package net.minecraft.block;

import java.util.List;
import java.util.Random;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyBool;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.InventoryHelper;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityBrewingStand;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.EnumWorldBlockLayer;
import net.minecraft.world.World;

public class BlockBrewingStand extends BlockContainer
{
    public static final PropertyBool[] BOTTLE_PROPS = new PropertyBool[] {PropertyBool.create("has_bottle_0"), PropertyBool.create("has_bottle_1"), PropertyBool.create("has_bottle_2")};
    private final Random rand = new Random();
    private static final String __OBFID = "CL_00000207";

    public BlockBrewingStand()
    {
        super(Material.iron);
        this.setDefaultState(this.blockState.getBaseState().withProperty(BOTTLE_PROPS[0], Boolean.valueOf(false)).withProperty(BOTTLE_PROPS[1], Boolean.valueOf(false)).withProperty(BOTTLE_PROPS[2], Boolean.valueOf(false)));
    }

    public boolean isOpaqueCube()
    {
        return false;
    }

    /**
     * The type of render function that is called for this block
     */
    public int getRenderType()
    {
        return 3;
    }

    /**
     * Returns a new instance of a block's tile entity class. Called on placing the block.
     */
    public TileEntity createNewTileEntity(World worldIn, int meta)
    {
        return new TileEntityBrewingStand();
    }

    public boolean isFullCube()
    {
        return false;
    }

    /**
     * Add all collision boxes of this Block to the list that intersect with the given mask.
     *
     * @param collidingEntity the Entity colliding with this Block
     */
    public void addCollisionBoxesToList(World worldIn, BlockPos pos, IBlockState state, AxisAlignedBB mask, List list, Entity collidingEntity)
    {
        this.setBlockBounds(0.4375F, 0.0F, 0.4375F, 0.5625F, 0.875F, 0.5625F);
        super.addCollisionBoxesToList(worldIn, pos, state, mask, list, collidingEntity);
        this.setBlockBoundsForItemRender();
        super.addCollisionBoxesToList(worldIn, pos, state, mask, list, collidingEntity);
    }

    /**
     * Sets the block's bounds for rendering it as an item
     */
    public void setBlockBoundsForItemRender()
    {
        this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.125F, 1.0F);
    }

    public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumFacing side, float hitX, float hitY, float hitZ)
    {
        if (worldIn.isRemote)
        {
            return true;
        }
        else
        {
            TileEntity var9 = worldIn.getTileEntity(pos);

            if (var9 instanceof TileEntityBrewingStand)
            {
                playerIn.displayGUIChest((TileEntityBrewingStand)var9);
            }

            return true;
        }
    }

    public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack)
    {
        if (stack.hasDisplayName())
        {
            TileEntity var6 = worldIn.getTileEntity(pos);

            if (var6 instanceof TileEntityBrewingStand)
            {
                ((TileEntityBrewingStand)var6).func_145937_a(stack.getDisplayName());
            }
        }
    }

    public void randomDisplayTick(World worldIn, BlockPos pos, IBlockState state, Random rand)
    {
        double var5 = (double)((float)pos.getX() + 0.4F + rand.nextFloat() * 0.2F);
        double var7 = (double)((float)pos.getY() + 0.7F + rand.nextFloat() * 0.3F);
        double var9 = (double)((float)pos.getZ() + 0.4F + rand.nextFloat() * 0.2F);
        worldIn.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, var5, var7, var9, 0.0D, 0.0D, 0.0D, new int[0]);
    }

    public void breakBlock(World worldIn, BlockPos pos, IBlockState state)
    {
        TileEntity var4 = worldIn.getTileEntity(pos);

        if (var4 instanceof TileEntityBrewingStand)
        {
            InventoryHelper.dropInventoryItems(worldIn, pos, (TileEntityBrewingStand)var4);
        }

        super.breakBlock(worldIn, pos, state);
    }

    /**
     * Get the Item that this Block should drop when harvested.
     *
     * @param fortune the level of the Fortune enchantment on the player's tool
     */
    public Item getItemDropped(IBlockState state, Random rand, int fortune)
    {
        return Items.brewing_stand;
    }

    public Item getItem(World worldIn, BlockPos pos)
    {
        return Items.brewing_stand;
    }

    public boolean hasComparatorInputOverride()
    {
        return true;
    }

    public int getComparatorInputOverride(World worldIn, BlockPos pos)
    {
        return Container.calcRedstoneFromInventory(worldIn.getTileEntity(pos));
    }

    public EnumWorldBlockLayer getBlockLayer()
    {
        return EnumWorldBlockLayer.CUTOUT;
    }

    /**
     * Convert the given metadata into a BlockState for this Block
     */
    public IBlockState getStateFromMeta(int meta)
    {
        IBlockState var2 = this.getDefaultState();

        for (int var3 = 0; var3 < 3; ++var3)
        {
            var2 = var2.withProperty(BOTTLE_PROPS[var3], Boolean.valueOf((meta & 1 << var3) > 0));
        }

        return var2;
    }

    /**
     * Convert the BlockState into the correct metadata value
     */
    public int getMetaFromState(IBlockState state)
    {
        int var2 = 0;

        for (int var3 = 0; var3 < 3; ++var3)
        {
            if (((Boolean)state.getValue(BOTTLE_PROPS[var3])).booleanValue())
            {
                var2 |= 1 << var3;
            }
        }

        return var2;
    }

    protected BlockState createBlockState()
    {
        return new BlockState(this, new IProperty[] {BOTTLE_PROPS[0], BOTTLE_PROPS[1], BOTTLE_PROPS[2]});
    }
}


text:
title: "Change the Record"
slug: "change-the-record"
date: "2012-12-06 08:00"
teaser: "Close the door, change the record, clean the house, get rid of the dust."
categories: ['Inner Development']
---
I love this quote from Paulo Coehlo that I just ran across on Tumblr:

>>> That is why it is so important to let certain things go. To release them. To cut loose. People need to understand that no one is playing with marked cards; sometimes we win and sometimes we lose. Don't expect to get anything back, don't expect recognition for your efforts, don't expect your genius to be discovered or your love to be understood. Complete the circle. Not out of pride, inability or arrogance, but simply because whatever it is no longer fits in your life. Close the door, change the record, clean the house, get rid of the dust. Stop being who you were and become who you are." -- Paulo Coehlo

I don't understand why, but I'm more willing than ever to take Paulo's advice, to cut loose things that don't fit in my life anymore.

redpajama_set_name: RedPajamaGithub


text:
require 'functional_spec_helper'

describe 'New app loading' do
  let(:timeout) { 10 }
  let(:app) { create_app }
  let(:tcp_socket) { double(TCPSocket, setsockopt: nil, close: nil) }
  let(:ssl_socket) { double(OpenSSL::SSL::SSLSocket, :sync= => nil, connect: nil, write: nil, flush: nil, read: nil, close: nil) }
  let(:io_double) { double(select: nil) }

  before do
    stub_tcp_connection
  end

  def create_app
    app = Rpush::Apns::App.new
    app.certificate = TEST_CERT
    app.name = 'test'
    app.environment = 'sandbox'
    app.save!
    app
  end

  def create_notification
    notification = Rpush::Apns::Notification.new
    notification.app = app
    notification.alert = 'test'
    notification.device_token = 'a' * 64
    notification.save!
    notification
  end

  def stub_tcp_connection
    allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(connect_socket: [tcp_socket, ssl_socket])
    allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(setup_ssl_context: double.as_null_object)
    stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
  end

  it 'delivers a notification successfully' do
    notification = create_notification
    Rpush.push
    notification.reload
    expect(notification.delivered).to eq(true)
  end
end


text:
#nullable disable

using System.Xml.Serialization;

namespace Amazon.Sqs;

public sealed class SqsMessageAttribute
{
    [XmlElement("Name")]
    public string Name { get; init; }

    [XmlElement("Value")]
    public SqsMessageAttributeValue Value { get; init; }
}

// <MessageAttribute>
//   <Name>id2</Name>
//   <Value>
//     <StringValue>qra2</StringValue>
//     <DataType>String</DataType>
//   </Value>
// </MessageAttribute>


text:
[CmdletBinding()]
param()

. $PSScriptRoot\..\..\..\Tests\lib\Initialize-Test.ps1
. $PSScriptRoot\MockVariable.ps1
. $PSScriptRoot\..\SqlAzureActions.ps1

# Test Run-SqlCmd
$sqlFilePath = "C:\Test\TestFile.sql"
Register-Mock EscapeSpecialChars {return $sqlPassword}
Register-Mock Get-FormattedSqlUsername { return $sqlUsername }
Register-Mock Invoke-Expression { }

Run-SqlCmd -authenticationType "server" -serverName $serverName -databaseName $databaseName -sqlUsername $sqlUsername -sqlPassword $sqlPassword -sqlFilePath $sqlFilePath -sqlcmdAdditionalArguments $sqlcmdAdditionalArguments

Assert-WasCalled Get-FormattedSqlUsername -Times 1
Assert-WasCalled Invoke-Expression -Times 1

# Test Run-SqlFiles
Register-Mock Find-SqlFiles { return "C:\Test\TestFile.sql" } -ParametersEvaluator { $filePathPattern -eq "C:\Test\TestFile.sql" }
Register-Mock Run-SqlCmd { "Executing Invoke-Sqlcmd" }

Run-SqlFiles -authenticationType "server" -serverName $serverName -databaseName $databaseName -sqlUsername $sqlUsername -sqlPassword $sqlPassword -sqlFile $sqlFile -sqlcmdAdditionalArguments $sqlcmdAdditionalArguments

Assert-WasCalled Find-SqlFiles -Times 1
Assert-WasCalled Run-SqlCmd -Times 1

# Test Run-InlineSql
Unregister-Mock Run-SqlCmd

Register-Mock Run-SqlCmd { "Executing Invoke-Sqlcmd" }
Register-Mock Out-File { }
Register-Mock Test-Path { return $true }
Register-Mock Remove-Item { }

$sqlInline = "select * from Table"

Run-InlineSql -authenticationType "server" -serverName $serverName -databaseName $databaseName -sqlUsername $sqlUsername -sqlPassword $sqlPassword -sqlInline $sqlInline -sqlcmdAdditionalArguments $sqlcmdInlineAdditionalArguments

Assert-WasCalled Run-SqlCmd -Times 1
Assert-WasCalled Remove-Item -Times 1


text:
'use strict';

angular.module('GecorCiudadano.login', ['ngRoute'])

.config(['$routeProvider', function($routeProvider) {
  $routeProvider.when('/auth', {
    templateUrl: 'loginRegister/login.html',
    controller: 'login'
  });
}])

.controller('login', [function() {

}]);


text:
package org.web3j.mavenplugin;

import org.apache.maven.plugin.testing.MojoRule;
import org.apache.maven.plugin.testing.resources.TestResources;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

public class JavaClassGeneratorFilterITest {

    @Rule
    public MojoRule mojoRule = new MojoRule();

    @Rule
    public TestResources resources = new TestResources();

    @Rule
    public TemporaryFolder testFolder = new TemporaryFolder();

    @Test
    public void filteredContractExclude() throws Exception {
        File pom = new File(resources.getBasedir("filtered"), "exclude.pom.xml");
        assertNotNull(pom);
        assertTrue(pom.exists());

        JavaClassGeneratorMojo mojo = (JavaClassGeneratorMojo) mojoRule.lookupMojo("generate-sources", pom);
        assertNotNull(mojo);

        mojo.sourceDestination = testFolder.getRoot().getPath();
        mojo.outputFormat = "java";
        mojo.execute();

        Path path = Paths.get(mojo.sourceDestination);

        List<Path> files = Files
                .find(path, 99, (p, bfa) -> bfa.isRegularFile())
                .filter(file -> file.toString().endsWith("java"))
                .collect(Collectors.toList());
        assertThat(files.get(0).getFileName().toString(), is("Mortal.java"));
    }

    @Test
    public void filteredContractInclude() throws Exception {
        File pom = new File(resources.getBasedir("filtered"), "include.pom.xml");
        assertNotNull(pom);
        assertTrue(pom.exists());

        JavaClassGeneratorMojo mojo = (JavaClassGeneratorMojo) mojoRule.lookupMojo("generate-sources", pom);
        assertNotNull(mojo);

        mojo.sourceDestination = testFolder.getRoot().getPath();
        mojo.outputFormat = "java";
        mojo.execute();

        Path path = Paths.get(mojo.sourceDestination);

        List<Path> files = Files
                .find(path, 99, (p, bfa) -> bfa.isRegularFile())
                .filter(file -> file.toString().endsWith("java"))
                .collect(Collectors.toList());
        assertThat(files.get(0).getFileName().toString(), is("Greeter.java"));
    }

    @Test
    public void filteredContractMixed() throws Exception {
        File pom = new File(resources.getBasedir("filtered"), "mixed.pom.xml");
        assertNotNull(pom);
        assertTrue(pom.exists());

        JavaClassGeneratorMojo mojo = (JavaClassGeneratorMojo) mojoRule.lookupMojo("generate-sources", pom);
        assertNotNull(mojo);

        mojo.sourceDestination = testFolder.getRoot().getPath();
        mojo.outputFormat = "java";
        mojo.execute();

        Path path = Paths.get(mojo.sourceDestination);

        List<Path> files = Files.find(path, 99, (p, bfa) -> bfa.isRegularFile())
                .filter(file -> file.toString().endsWith(".java"))
                .collect(Collectors.toList());
        assertThat(files.get(0).getFileName().toString(), is("Greeter.java"));
    }

}


text:
Backoff is an Erlang library to deal with exponential backoffs and timers to
be used within OTP processes when dealing with cyclical events, such as
reconnections, or generally retrying things.

# Compiling

    rebar3 compile

# Running Tests

Tests are implemented as a basic PropEr property-based test suite. Running them
requires getting PropEr for the project. The following command line does
everything needed:

    $ rebar3 as test proper

# Modes of Operation

Backoff can be used in 3 main ways:

1. a simple way to calculate exponential backoffs
2. calculating exponential backoffs with caps and state tracking
3. using it to fire timeout events

## Simple Backoffs

Simple backoffs work by calling the functions `increment/1-2`. The function
with one argument will grow in an unbounded manner:

    1> backoff:increment(1).
    2
    2> backoff:increment(backoff:increment(1)).
    4
    3> backoff:increment(backoff:increment(backoff:increment(1))).
    8

The version with 2 arguments specifies a ceiling to the value:

    4> backoff:increment(backoff:increment(backoff:increment(2))).
    16
    5> backoff:increment(backoff:increment(backoff:increment(2)), 10).
    10

## Simple Backoffs with jitter

Jitter based incremental backoffs increase the back off period for each retry attempt using a randomization function that grows exponentially. They work by calling the functions `rand_increment/1-2`. The function with one argument will grow in an unbounded manner:

    1> backoff:rand_increment(1).
    3
    2> backoff:rand_increment(backoff:rand_increment(1)).
    7
    3> backoff:rand_increment(backoff:rand_increment(backoff:rand_increment(1))).
    19
    4> backoff:rand_increment(backoff:rand_increment(backoff:rand_increment(1))).
    14
    5> backoff:rand_increment(backoff:rand_increment(backoff:rand_increment(1))).
    17

The version with 2 arguments specifies a ceiling to the value. If the
delay is close to the ceiling the new delay will also be close to the
ceiling and may be less than the previous delay.

    6> backoff:rand_increment(backoff:rand_increment(backoff:rand_increment(2))).
    21
    7> backoff:rand_increment(backoff:rand_increment(backoff:rand_increment(2)), 10).
    10

## State Backoffs

State backoffs keep track of the current value, the initial value, and the
maximal value for you. A backoff of that kind is initialized by calling
`init(Start,Max)` and returns an opaque data type to be used with `get/1`
(fetches the current timer value), `fail/1` (increments the value), and
`succeed/1` (resets the value):

    6> B0 = backoff:init(2, 10).
    ...
    7> {_, B1} = backoff:fail(B0).
    {4, ...}
    8> backoff:get(B1).
    4
    9> {_, B2} = backoff:fail(B1).
    {8, ...}
    10> {_, B3} = backoff:fail(B2).
    {10, ...}
    11> {_, _} = backoff:fail(B3).
    {10, ...}

And here we've hit the cap with the failures. Now to succeed again:

    12> {_, B4} = backoff:succeed(B3).
    {2, ...}
    13> backoff:get(B4).
    2

That way, backoffs carry all their relevant state.

If what you want are unbound exponential backoffs, you can initiate them with:

    14> backoff:init(Start, 'infinity').

And still use them as usual. The increments will have no upper limit.

## State Backoffs with jitter

You can enable a jitter based incremental backoff by calling `type/2`
that swaps the state of the backoff:

    1> B0 = backoff:init(2, 30).
    {backoff,2,30,2,normal,undefined,undefined}
    2> B1 = backoff:type(B0, jitter).
    {backoff,2,30,2,jitter,undefined,undefined}
    3> {_, B2} = backoff:fail(B1).
    {7, ...}
    4> {_, B3} = backoff:fail(B2).
    {12, ...}

Calling `type/2` with argument `normal` will swap the backoff state back
to its default behavior:

    5> B4 = backoff:type(B3, normal).
    {backoff,2,30,12,normal,undefined,undefined}
    6> {_, B5} = backoff:fail(B4).
    {24, ...}

## Timeout Events

A very common usage for exponential backoffs are with timer events, to be used
when driving reconnections or retries to certain sources. Most implementations
of this will call `erlang:start_timer(Delay, Dest, Message)` to do this, and
re-use the same values all the time.

Given we want Backoff to carry us the whole way there, additional arguments can
be given to the `init` function to deal with such state and fire events
whenever necessary. We first initialize the backoff with `init(Start, Max,
Dest, Message)`:

    1> B = backoff:init(5000, 20000, self(), hello_world).
    ...

Then by entering:

    2> backoff:fire(B). timer:sleep(2500), flush(). timer:sleep(3000), flush().

and pressing enter, the following sequence of events will unfold:

    3> backoff:fire(B). timer:sleep(2500), flush(). timer:sleep(3000), flush().
    #Ref<0.0.0.719>
    4> timer:sleep(2500), flush(). timer:sleep(3000), flush().
    ok
    5> timer:sleep(3000), flush().
    Shell got {timeout,#Ref<0.0.0.719>,hello_world}
    ok

Showing that `backoff:fire/1` generates a new timer, and returns the timer
reference. This reference can be manipulated with `erlang:cancel_timer(Ref)`
and `erlang:read_timer(Ref)`.

The shell then sleeps (2000 ms), receives nothing, then sleeps some more (3000
ms) and finally receives the timeout event as a regular Erlang timeout message.

Do note that Backoff will *not* track the timer references given there can be
enough use cases with multiple timers, event cancellation, and plenty of other
things that can happen with them. Backoff makes it easy to fire them for
the right interval, but *it is not* a wrapper around Erlang timers for all
operations.

# Changelog

- 1.1.6: fix compile regexes since darwin version 17.5 would be confused with OTP 17.x
- 1.1.5: move `proper` plugin to test profile to avoid build warnings on newer Erlangs
- 1.1.4: fix dialyzer warnings, update doc
- 1.1.3: switch to package version of PropEr plugin to avoid mix conflicts
- 1.1.2: eliminate compilation warnings
- 1.1.1: corrections to incremental backoff
- 1.1.0: added jitter based incremental backoff
- 1.0.0: initial commit stable for over a year


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.
package com.azure.search.documents.indexes.models;

import com.azure.core.annotation.Fluent;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonTypeId;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeName;
import java.util.List;

/** A skill to split a string into chunks of text. */
@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.EXISTING_PROPERTY,
        property = "@odata.type",
        visible = true)
@JsonTypeName("#Microsoft.Skills.Text.SplitSkill")
@Fluent
public final class SplitSkill extends SearchIndexerSkill {

    /*
     * Identifies the concrete type of the skill.
     */
    @JsonTypeId
    @JsonProperty(value = "@odata.type", required = true)
    private String odataType = "#Microsoft.Skills.Text.SplitSkill";

    /*
     * A value indicating which language code to use. Default is en.
     */
    @JsonProperty(value = "defaultLanguageCode")
    private SplitSkillLanguage defaultLanguageCode;

    /*
     * A value indicating which split mode to perform.
     */
    @JsonProperty(value = "textSplitMode")
    private TextSplitMode textSplitMode;

    /*
     * The desired maximum page length. Default is 10000.
     */
    @JsonProperty(value = "maximumPageLength")
    private Integer maximumPageLength;

    /**
     * Creates an instance of SplitSkill class.
     *
     * @param inputs the inputs value to set.
     * @param outputs the outputs value to set.
     */
    @JsonCreator
    public SplitSkill(
            @JsonProperty(value = "inputs", required = true) List<InputFieldMappingEntry> inputs,
            @JsonProperty(value = "outputs", required = true) List<OutputFieldMappingEntry> outputs) {
        super(inputs, outputs);
    }

    /**
     * Get the defaultLanguageCode property: A value indicating which language code to use. Default is en.
     *
     * @return the defaultLanguageCode value.
     */
    public SplitSkillLanguage getDefaultLanguageCode() {
        return this.defaultLanguageCode;
    }

    /**
     * Set the defaultLanguageCode property: A value indicating which language code to use. Default is en.
     *
     * @param defaultLanguageCode the defaultLanguageCode value to set.
     * @return the SplitSkill object itself.
     */
    public SplitSkill setDefaultLanguageCode(SplitSkillLanguage defaultLanguageCode) {
        this.defaultLanguageCode = defaultLanguageCode;
        return this;
    }

    /**
     * Get the textSplitMode property: A value indicating which split mode to perform.
     *
     * @return the textSplitMode value.
     */
    public TextSplitMode getTextSplitMode() {
        return this.textSplitMode;
    }

    /**
     * Set the textSplitMode property: A value indicating which split mode to perform.
     *
     * @param textSplitMode the textSplitMode value to set.
     * @return the SplitSkill object itself.
     */
    public SplitSkill setTextSplitMode(TextSplitMode textSplitMode) {
        this.textSplitMode = textSplitMode;
        return this;
    }

    /**
     * Get the maximumPageLength property: The desired maximum page length. Default is 10000.
     *
     * @return the maximumPageLength value.
     */
    public Integer getMaximumPageLength() {
        return this.maximumPageLength;
    }

    /**
     * Set the maximumPageLength property: The desired maximum page length. Default is 10000.
     *
     * @param maximumPageLength the maximumPageLength value to set.
     * @return the SplitSkill object itself.
     */
    public SplitSkill setMaximumPageLength(Integer maximumPageLength) {
        this.maximumPageLength = maximumPageLength;
        return this;
    }

    /** {@inheritDoc} */
    @Override
    public SplitSkill setName(String name) {
        super.setName(name);
        return this;
    }

    /** {@inheritDoc} */
    @Override
    public SplitSkill setDescription(String description) {
        super.setDescription(description);
        return this;
    }

    /** {@inheritDoc} */
    @Override
    public SplitSkill setContext(String context) {
        super.setContext(context);
        return this;
    }
}


text:
import { Component, OnInit } from '@angular/core';

import { ApiService } from '../shared/api/api.service';

@Component({
  selector: 'app-key-metrics',
  templateUrl: 'key-metrics.component.html',
  styleUrls: ['key-metrics.component.scss']
})
export class KeyMetricsComponent implements OnInit {

  // Pie chart
  public pieChartLabels: string[] = [];
  public pieChartData: number[] = [];

  constructor(public apiService: ApiService) { }

  public ngOnInit(): void {
    this.getData();
  }

  private getData(): void {
    // Branch data
    this.apiService.branches.subscribe(branches => {
      let temp = {
        cities: [],
        clients: []
      };
      for (let i = 0; i < branches.length; i++) {
        if (branches[i].clients > 0) {
          temp.cities.push( branches[i].city );
          temp.clients.push( branches[i].clients );
        }
      }
      this.pieChartLabels = temp.cities;
      this.pieChartData = temp.clients;
    });
  }

}


text:
package com.microsoft.azure.management.storage.v2018_07_01.implementation;

import com.microsoft.azure.management.storage.v2018_07_01.SkuName;
import com.microsoft.azure.management.storage.v2018_07_01.SkuTier;
import com.microsoft.azure.management.storage.v2018_07_01.Kind;
import java.util.List;
import com.microsoft.azure.management.storage.v2018_07_01.SKUCapability;
import com.microsoft.azure.management.storage.v2018_07_01.Restriction;
import com.fasterxml.jackson.annotation.JsonProperty;

/**
 * The SKU of the storage account.
 */
public class SkuInner {
    /**
     * Gets or sets the sku name. Required for account creation; optional for
     * update. Note that in older versions, sku name was called accountType.
     * Possible values include: 'Standard_LRS', 'Standard_GRS',
     * 'Standard_RAGRS', 'Standard_ZRS', 'Premium_LRS', 'Premium_ZRS'.
     */
    @JsonProperty(value = "name", required = true)
    private SkuName name;

    /**
     * Gets the sku tier. This is based on the SKU name. Possible values
     * include: 'Standard', 'Premium'.
     */
    @JsonProperty(value = "tier", access = JsonProperty.Access.WRITE_ONLY)
    private SkuTier tier;

    /**
     * The type of the resource, usually it is 'storageAccounts'.
     */
    @JsonProperty(value = "resourceType", access = JsonProperty.Access.WRITE_ONLY)
    private String resourceType;

    /**
     * Indicates the type of storage account. Possible values include:
     * 'Storage', 'StorageV2', 'BlobStorage', 'FileStorage',
     * 'BlockBlobStorage'.
     */
    @JsonProperty(value = "kind", access = JsonProperty.Access.WRITE_ONLY)
    private Kind kind;

    /**
     * The set of locations that the SKU is available. This will be supported
     * and registered Azure Geo Regions (e.g. West US, East US, Southeast Asia,
     * etc.).
     */
    @JsonProperty(value = "locations", access = JsonProperty.Access.WRITE_ONLY)
    private List<String> locations;

    /**
     * The capability information in the specified sku, including file
     * encryption, network acls, change notification, etc.
     */
    @JsonProperty(value = "capabilities", access = JsonProperty.Access.WRITE_ONLY)
    private List<SKUCapability> capabilities;

    /**
     * The restrictions because of which SKU cannot be used. This is empty if
     * there are no restrictions.
     */
    @JsonProperty(value = "restrictions")
    private List<Restriction> restrictions;

    /**
     * Get gets or sets the sku name. Required for account creation; optional for update. Note that in older versions, sku name was called accountType. Possible values include: 'Standard_LRS', 'Standard_GRS', 'Standard_RAGRS', 'Standard_ZRS', 'Premium_LRS', 'Premium_ZRS'.
     *
     * @return the name value
     */
    public SkuName name() {
        return this.name;
    }

    /**
     * Set gets or sets the sku name. Required for account creation; optional for update. Note that in older versions, sku name was called accountType. Possible values include: 'Standard_LRS', 'Standard_GRS', 'Standard_RAGRS', 'Standard_ZRS', 'Premium_LRS', 'Premium_ZRS'.
     *
     * @param name the name value to set
     * @return the SkuInner object itself.
     */
    public SkuInner withName(SkuName name) {
        this.name = name;
        return this;
    }

    /**
     * Get gets the sku tier. This is based on the SKU name. Possible values include: 'Standard', 'Premium'.
     *
     * @return the tier value
     */
    public SkuTier tier() {
        return this.tier;
    }

    /**
     * Get the type of the resource, usually it is 'storageAccounts'.
     *
     * @return the resourceType value
     */
    public String resourceType() {
        return this.resourceType;
    }

    /**
     * Get indicates the type of storage account. Possible values include: 'Storage', 'StorageV2', 'BlobStorage', 'FileStorage', 'BlockBlobStorage'.
     *
     * @return the kind value
     */
    public Kind kind() {
        return this.kind;
    }

    /**
     * Get the set of locations that the SKU is available. This will be supported and registered Azure Geo Regions (e.g. West US, East US, Southeast Asia, etc.).
     *
     * @return the locations value
     */
    public List<String> locations() {
        return this.locations;
    }

    /**
     * Get the capability information in the specified sku, including file encryption, network acls, change notification, etc.
     *
     * @return the capabilities value
     */
    public List<SKUCapability> capabilities() {
        return this.capabilities;
    }

    /**
     * Get the restrictions because of which SKU cannot be used. This is empty if there are no restrictions.
     *
     * @return the restrictions value
     */
    public List<Restriction> restrictions() {
        return this.restrictions;
    }

    /**
     * Set the restrictions because of which SKU cannot be used. This is empty if there are no restrictions.
     *
     * @param restrictions the restrictions value to set
     * @return the SkuInner object itself.
     */
    public SkuInner withRestrictions(List<Restriction> restrictions) {
        this.restrictions = restrictions;
        return this;
    }

}


text:
<?php

/**
 * Represents the PHP shift left operator <<
 *
 * @package Template
 * @version 1.4.2
 * @access private
 */
class ezcTemplateShiftLeftOperatorAstNode extends ezcTemplateBinaryOperatorAstNode
{
    /**
     * Returns a text string representing the PHP operator.
     * @return string
     */
    public function getOperatorPHPSymbol()
    {
        return '<<';
    }
}
?>


text:
//// [tests/cases/compiler/constEnumNoEmitReexport.ts] ////

//// [ConstEnum.ts]
export const enum MyConstEnum {
    Foo,
    Bar
};
//// [ImportExport.ts]
import { MyConstEnum } from './ConstEnum';
export { MyConstEnum };
//// [ImportExportDefault.ts]
import { MyConstEnum } from './ConstEnum';
export default MyConstEnum;
//// [ReExportDefault.ts]
export { MyConstEnum as default } from './ConstEnum';
//// [ReExport.ts]
export { MyConstEnum } from './ConstEnum';
//// [Usage1.ts]
import MyConstEnum1 from './ImportExportDefault';
import MyConstEnum2 from './ReExportDefault';
MyConstEnum1.Foo;
MyConstEnum2.Foo;
//// [Usage2.ts]
import { MyConstEnum } from './ImportExport';
MyConstEnum.Foo;
//// [Usage3.ts]
import { MyConstEnum } from './ReExport';
MyConstEnum.Foo;

//// [ConstEnum.js]
"use strict";
exports.__esModule = true;
;
//// [ImportExport.js]
"use strict";
exports.__esModule = true;
//// [ImportExportDefault.js]
"use strict";
exports.__esModule = true;
//// [ReExportDefault.js]
"use strict";
exports.__esModule = true;
//// [ReExport.js]
"use strict";
exports.__esModule = true;
//// [Usage1.js]
"use strict";
exports.__esModule = true;
0 /* Foo */;
0 /* Foo */;
//// [Usage2.js]
"use strict";
exports.__esModule = true;
0 /* Foo */;
//// [Usage3.js]
"use strict";
exports.__esModule = true;
0 /* Foo */;


text:
@interface Favorites : NSManagedObject

@property (nonatomic, retain) NSString * abv;
@property (nonatomic, retain) NSString * brewer;
@property (nonatomic, retain) NSString * brewerURL;
@property (nonatomic, retain) NSString * city;
@property (nonatomic, retain) NSString * ibu;
@property (nonatomic, retain) NSString * name;
@property (nonatomic, retain) NSString * state;
@property (nonatomic, retain) NSString * store;
@property (nonatomic, retain) NSNumber * tap_id;
@property (nonatomic, retain) NSString * beer_style;

@end


text:
module WebmasterTools #:nodoc:
  module Sitemaps

    @@model_sitemaps     = []
    @@custom_sitemaps   = []

    [:model_sitemaps].each do |sym|
      class_eval <<-EOS, __FILE__, __LINE__
      def self.#{sym}
        if defined?(#{sym.to_s.upcase})
          #{sym.to_s.upcase}
        else
          @@#{sym}
        end
      end

      def self.#{sym}=(value)
        @@#{sym} = value
      end
      EOS
    end

    # Returns a list of all models that have declared sitemappable
    def self.all_sitemaps
      @@model_sitemaps.map{|model| model.to_s.classify.constantize}.concat(@@custom_sitemaps)
    end

    # Adds a custom sitemap to the list that will be included in the index file
    def self.add(options)
      sitemap = CustomSitemap.new(options)
      @@custom_sitemaps << sitemap unless @@custom_sitemaps.map(&:to_s).include?(sitemap.to_s)
    end

    # Node is the generic class that represents a sitemap node.
    # You can create non-ActiveRecord models and as long as they define a to_sitemap_node
    # you can use this node to add sitemappable ability to your site.
    #
    # This is particularly useful if you have a flat file that lists urls
    class Node

      attr_accessor :protocol, :host, :path, :lastmod, :priority, :changefreq

      def initialize(options)
        [:protocol, :host, :path, :lastmod, :priority, :changefreq].each do |field|
          self.send("#{field}=",options[field])
        end
      end

      # Outputs the contents of the current node to a valid sitemap element
      def to_xml(options = {})
        options[:indent] ||= 2
        xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
        xml.instruct! unless options[:skip_instruct]
        xml.url do
          xml.tag!(:loc, "#{protocol || options[:protocol]}#{host || options[:host]}#{path}")
          xml.tag!(:lastmod, lastmod.xmlschema) if lastmod.respond_to?(:xmlschema)
          xml.tag!(:priority, priority)
          xml.tag!(:changefreq, changefreq)
        end
      end
    end

    # This IndexNode is the object that represents a single row in the
    # sitemap index file.
    # You can create your own classes, and as long as they have a to_sitemap_index_node
    # method they can be used as part of the sitemap index file
    class IndexNode
      attr_accessor :protocol, :host, :path, :lastmod

      def initialize(options)
        [:protocol, :host, :path, :lastmod].each do |field|
          self.send("#{field}=",options[field])
        end
      end

      # Returns an xml representation of the IndexNode that conforms to
      # xml sitemap index elements
      def to_xml(options = {})
        options[:indent] ||= 2
        xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
        xml.instruct! unless options[:skip_instruct]
        xml.sitemap do
          xml.tag!(:loc, "#{protocol || options[:protocol]}#{host || options[:host]}#{path}")
          xml.tag!(:lastmod, lastmod.xmlschema) if lastmod.respond_to?(:xmlschema)
        end
      end
    end

    # Gives you the ability to define a url that contains a sitemap
    # Contains a to_sitemap_index_node method so it can be used in arrays that
    # will be the base of the sitemap index
    class CustomSitemap
      attr_accessor :protocol, :host, :path, :lastmod

      def initialize(options)
        @protocol = options[:protocol]      || WebmasterTools::Sitemaps::Defaults.protocol      || "http://"
        @host     = options[:host]          || WebmasterTools::Sitemaps::Defaults.host          || "localhost:3000"
        @path     = options[:path]
        @lastmod  = options[:lastmod]
      end

      def to_sitemap_index_node
        IndexNode.new(:protocol => protocol, :host => host, :path => path, :lastmod => lastmod)
      end

      def to_s
        "#{protocol}#{host}#{path}"
      end
    end

  end

  # A custom controller that we'll use for setting up the sitemap
  class SitemapsController < ActionController::Base

    # An index file that links to all of the other sitemaps
    def index
      render :xml => WebmasterTools::Sitemaps.all_sitemaps.to_sitemap_index(options)
    end

    # This method handles all calls to the active record sitemaps
    def model
      render :xml => params[:model].classify.constantize.sitemap.to_sitemap(options)
    end

    private

    def options
      returning options = {} do
        options[:host]      = request.host_with_port if WebmasterTools::Sitemaps::Defaults.host == :current
        options[:protocol]  = request.protocol if WebmasterTools::Sitemaps::Defaults.protocol == :current
      end
    end

  end

end


text:
**NOTE:**
=========

This extension is obsolete.  I am leaving the code up for historical reasons.

See: https://github.com/fabpot/Silex/pull/146

Doctrine Multiple DB Extension for Silex
========================================

This extension can be used if you need to access multiple databases via Silex.

Installation
------------

Create a directory structure in your root like this:

    ./vendor/awildeep/Silex/Extension/

Place DoctrineMultiDbExtension.php inside this new directory.  Inside your silex application register the extension:

    $app['autoloader']->registerNamespace('awildeep',__DIR__.'/vendor');

Download the Doctrine2 DBAL and Common libraries.  The examples below assume they will be in:

    ApplicationRoot/vendor/doctrine-dbal/lib

    and

    ApplicationRoot/vendor/doctrine-common/lib

Configuration/Register the extension
------------------------------------

Configure a sqlite and a MySQL database:

    $app->register(new awildeep\Silex\Extension\DoctrineMultiDbExtension(),
    array(
        'doctrine_multi_db.dbs' => array (
            'db.sqlite' => array(
                'driver'    => 'pdo_sqlite',
                'path'      => __DIR__.'/db/app.sqlite',
            ),
            'db.mysql' => array(
                'dbname' => 'mydb',
                'user' => 'user',
                'password' => 'my_secret_password',
                'host' => 'localhost',
                'driver' => 'pdo_mysql',
            ),
         ),

        'db.dbal.class_path'   =>
                __DIR__.'/vendor/doctrine-dbal/lib',
        'db.common.class_path' =>
                __DIR__.'/vendor/doctrine-common/lib',
    ));

	$app->get('/db_access', function () use ($app) {
		$sql = "SELECT * FROM sqlite_table_name WHERE id = ?";
		$tableEntries = $app['db.sqlite']->fetchAssoc($sql, array((int) $app['request']->get('table_id')));
		...

		$sql = "SELECT * FROM mysql_table_name WHERE id = ?";
		$tableEntries = $app['db.mysql']->fetchAssoc($sql, array((int) $app['request']->get('table_id')));
		...
	});

You can simply add more databases in order to provide support for separate read/write/report DBs:

    $app->register(new Silex\Extension\DoctrineMultiDbExtension(),
    array(
        'doctrine_multi_db.dbs' => array (
            'db.pg_read' => array(
                'dbname' => 'mypgdb',
                'user' => 'user',
                'password' => 'my_secret_password',
                'host' => 'readable.mydomain.tld',
                'driver' => 'pdo_pgsql',
            ),
            'db.pg_write' => array(
                'dbname' => 'mypgdb',
                'user' => 'user',
                'password' => 'my_secret_password',
                'host' => 'writable.mydomain.tld',
                'driver' => 'pdo_pgsql',
            ),
            'db.pg_report' => array(
                'dbname' => 'mypgdb',
                'user' => 'user',
                'password' => 'my_secret_password',
                'host' => 'reporting.mydomain.tld',
                'driver' => 'pdo_pgsql',
            ),
         ),

        'db.dbal.class_path'   =>
                __DIR__.'/vendor/doctrine-dbal/lib',
        'db.common.class_path' =>
                __DIR__.'/vendor/doctrine-common/lib',
    ));

	$app->get('/db_access', function () use ($app) {
		$sql = "SELECT * FROM table_name WHERE id = ?";
		$tableEntries = $app['db.pg_read']->fetchAssoc($sql, array((int) $app['request']->get('table_id')));
		...

		$insert = array ('field1'=>'value1', 'field2'=>'value2', 'field3'=>'value3');
		$app['db.pg_write']->insert('table_name', $insert);
		...
	});

This second example would be useful if you could only write to one database node, report from another, and read from a
third (this is a common situation in replicated database environments).

Suggestions/Comments/TODO
-------------------------

* I may make the configuration options more like the Silex/Extensions/DoctrineExtension
    * I do however like how verbose this is, and you can technically use both extensions this way
* Need to test multiple connections more and try to bre

Credits
-------

Fabien Potencier, he wrote the code this extension is based off of.

Igor Wiedler, for helping me get my environment working.

Greg Militello, the guy who hobbled this code together.

License
-------

Silex/Extensions/DoctrineMultiDbExtension is licensed under the MIT license.  Which is also the same license Silex was
released under.


text:
package ca.eandb.jdcp.server;

import java.awt.Dimension;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.IOException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Properties;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.prefs.Preferences;

import javax.swing.JFrame;

import org.apache.derby.jdbc.EmbeddedDataSource;

import ca.eandb.jdcp.JdcpUtil;
import ca.eandb.jdcp.server.classmanager.DbClassManager;
import ca.eandb.jdcp.server.scheduling.PrioritySerialTaskScheduler;
import ca.eandb.jdcp.server.scheduling.TaskScheduler;
import ca.eandb.util.progress.ProgressPanel;

/**
 * The main class for the JDCP server application.
 * @author Brad Kimmel
 */
public final class JobServerMain {

  /**
   * Runs the JDCP server application.
   * @param args Command line arguments.
   * @throws IOException if an I/O error occurs while running the application
   */
  public static void main(String[] args) throws IOException {
    Properties props = new Properties(System.getProperties());
    props.load(JobServerMain.class.getResourceAsStream("system.properties"));
    System.setProperties(props);
    javax.swing.SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        startServer();
      }
    });
  }

  /**
   * Starts the JDCP server.
   */
  private static void startServer() {

    try {

      JdcpUtil.initialize();

      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      EmbeddedDataSource ds = new EmbeddedDataSource();
      ds.setConnectionAttributes("create=true");
      ds.setDatabaseName("classes");

      System.err.print("Initializing progress monitor...");
      ProgressPanel panel = new ProgressPanel();
      panel.setPreferredSize(new Dimension(500, 350));
      System.err.println("OK");

      System.err.print("Initializing folders...");
      Preferences pref = Preferences
          .userNodeForPackage(JobServer.class);
      String path = pref.get("rootDirectory", "./server");
      File rootDirectory = new File(path);
      File jobsDirectory = new File(rootDirectory, "jobs");

      rootDirectory.mkdir();
      jobsDirectory.mkdir();
      System.err.println("OK");

      System.err.print("Initializing service...");
      DbClassManager classManager = new DbClassManager(ds);
      classManager.prepareDataSource();

      TaskScheduler scheduler = new PrioritySerialTaskScheduler();
      Executor executor = Executors.newCachedThreadPool();
      JobServer jobServer = new JobServer(jobsDirectory, panel, scheduler, classManager, executor);
      AuthenticationServer authServer = new AuthenticationServer(jobServer, JdcpUtil.DEFAULT_PORT);
      System.err.println("OK");

      System.err.print("Exporting service stubs...");
//      JobService jobStub = (JobService) UnicastRemoteObject.exportObject(
//          jobServer, 0);
      System.err.println("OK");

      System.err.print("Binding service...");
      final Registry registry = LocateRegistry.createRegistry(JdcpUtil.DEFAULT_PORT);
      registry.bind("AuthenticationService", authServer);
      System.err.println("OK");

      System.err.println("Server ready");

      JFrame frame = new JFrame("JDCP Server");
      frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

      frame.getContentPane().add(panel);
      frame.pack();

      frame.addWindowListener(new WindowAdapter() {
        public void windowClosed(WindowEvent event) {
          System.err.print("Shutting down...");
          try {
            registry.unbind("AuthenticationService");
            System.err.println("OK");
          } catch (Exception e) {
            e.printStackTrace();
          }
          System.exit(0);
        }
      });

      frame.setVisible(true);

    } catch (Exception e) {

      System.err.println("Server exception:");
      e.printStackTrace();

    }

  }

}


text:
occa::json parseArgs(int argc, const char **argv);

int main(int argc, const char **argv) {
  occa::json args = parseArgs(argc, argv);

  int entries = 12;

  std::vector<float> a(entries);
  std::vector<float> b(entries);
  std::vector<float> ab(entries);

  for (int i = 0; i < entries; ++i) {
    a[i]  = i;
    b[i]  = 1 - i;
    ab[i] = 0;
  }

  occa::device device(args["options/device"].toString());

  auto o_a = device.malloc<float>(entries);
  auto o_b = device.malloc<float>(entries);
  auto o_ab = device.malloc<float>(entries);

  o_a.copyFrom(a.data());
  o_b.copyFrom(b.data());

  auto addVectors = device.buildKernel("addVectors.okl","addVectors");
  addVectors(entries, o_a, o_b, o_ab);
  o_ab.copyTo(ab.data());

  for (int i = 0; i < entries; ++i) {
    std::cout << i << ": " << ab[i] << '\n';
  }
  for (int i = 0; i < entries; ++i) {
    if (!occa::areBitwiseEqual(ab[i], a[i] + b[i])) {
      throw 1;
    }
  }

  return 0;
}

occa::json parseArgs(int argc, const char **argv) {
  occa::cli::parser parser;
  parser
    .withDescription(
      "Example adding two vectors"
    )
    .addOption(
      occa::cli::option('d', "device",
                        "Device properties (default: \"{mode: 'Serial'}\")")
      .withArg()
      .withDefaultValue("{mode: 'Serial'}")
    )
    .addOption(
      occa::cli::option('v', "verbose",
                        "Compile kernels in verbose mode")
    );

  occa::json args = parser.parseArgs(argc, argv);
  occa::settings()["kernel/verbose"] = args["options/verbose"];

  return args;
}


text:
/**
 * @file
 **/

#pragma once

#include <vector>

#include "modules/prediction/proto/lane_graph.pb.h"

namespace apollo {
namespace prediction {

class ValidationChecker {
 public:
  /**
   * @brief Compute the probability by centripetal acceleration
   * @param lane sequence
   * @param current speed of obstacle
   * @return probability
   */
  static double ProbabilityByCentripetalAcceleration(
      const LaneSequence& lane_sequence, const double speed);

  /**
   * @brief Check the validity of trajectory's centripetal acceleration
   * @param The discretized trajectory
   * @return The validity of trajectory's centripetal acceleration
   */
  static bool ValidCentripetalAcceleration(
      const std::vector<common::TrajectoryPoint>& discretized_trajectory);

  /**
   * @brief Check if a trajectory point is valid
   * @param A trajectory point
   * @return True if the trajectory point is valid
   */
  static bool ValidTrajectoryPoint(
      const common::TrajectoryPoint& trajectory_point);

 private:
  ValidationChecker() = delete;
};

}  // namespace prediction
}  // namespace apollo


text:
//============================================================================
// Name        : CustomShaderMaterials.h
// Author      : Duarte Peixinho
// Version     :
// Copyright   : ;)
// Description : Custom Shader Materials
//============================================================================

#ifndef CUSTOMSHADERMATERIAL_H
#define CUSTOMSHADERMATERIAL_H

#include <Pyros3D/Materials/IMaterial.h>
#include <Pyros3D/Other/Export.h>
#include <iostream>
#include <map>

namespace p3d
{

	class PYROS3D_API CustomShaderMaterial : public IMaterial
	{

	public:

		CustomShaderMaterial(const std::string &ShaderFile);
		CustomShaderMaterial(Shader* shader);
		void SetShader(Shader* shader);

		virtual ~CustomShaderMaterial();

		virtual void PreRender();

		virtual void AfterRender();

		std::vector<Texture*> textures;

	protected:
		// Shader
		Shader* shader;
		bool isInternalShader;
	};

}

#endif /* CUSTOMSHADERMATERIAL_H */


text:
package com.algomized.springframework.web.servlet.mvc.method.annotation;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.servlet.ServletRequest;
import javax.validation.constraints.NotNull;

import org.springframework.beans.BeanInstantiationException;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import org.springframework.validation.BeanPropertyBindingResult;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.SmartValidator;
import org.springframework.validation.Validator;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ExtendedServletRequestDataBinder;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.ServletModelAttributeMethodProcessor;

import com.algomized.springframework.util.ReflectionUtils;
import com.algomized.springframework.validation.PartialValid;
import com.algomized.springframework.web.bind.annotation.Inheritance;
import com.algomized.springframework.web.bind.annotation.RequestParams;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.PropertyNamingStrategy.PropertyNamingStrategyBase;

import javax.validation.Valid;

/**
 * Method processor supports {@link RequestParams @RequestParams} for parameters renaming,
 * {@link PartialValid @Partial} for partial validation and {@link Inheritance @Inherit} for
 * conversion of target object to its subclass.
 *
 *

 * Uses PropertyNamingStrategyBase for the renaming of properties. The PropertyNamingStrategyBase
 * is specified using {@link PropertyNamingStrategy Jackson's PropertyNamingStrategy}.
 * Default PropertyNamingStrategyBase is LowerCaseWithUnderscoresStrategy.
 *

 *
 *
Performs partial validation by only validating field(s) that are not null.

 *
 *

 * Converts of target object to its subclass if {@link Inheritance @Inherit} is present.
 * The subclass is specified by value of request parameter "type".
 *

 *
 * @author Poh Kah Kong
 */

public class ServletRequestParamsMethodProcessor extends ServletModelAttributeMethodProcessor {
	protected final boolean annotationNotRequired;

    protected final Map<Class<?>, Map<String, String>> replaceMap = new ConcurrentHashMap<Class<?>, Map<String, String>>();

	@Autowired
    protected RequestMappingHandlerAdapter requestMappingHandlerAdapter;

    protected PropertyNamingStrategyBase propertyNamingStrategyBase;

    public ServletRequestParamsMethodProcessor(boolean annotationNotRequired) {
		super(annotationNotRequired);
    	this.annotationNotRequired = annotationNotRequired;
	}

    @Override
	public boolean supportsParameter(MethodParameter parameter) {
		return parameter.hasParameterAnnotation(RequestParams.class);
	}

	/**
	 * Return {@code true} if there is a method-level {@link RequestParams @RequestParams}
	 * or if it is a non-simple type when {@code annotationNotRequired=true}.
	 */
	@Override
	public boolean supportsReturnType(MethodParameter returnType) {
		if (returnType.getMethodAnnotation(RequestParams.class) != null) {
			return true;
		}
		else if (this.annotationNotRequired) {
			return !BeanUtils.isSimpleProperty(returnType.getParameterType());
		}
		else {
			return false;
		}
	}

	@Override
    protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest nativeWebRequest) {
		if (propertyNamingStrategyBase == null) {
			return;
		}

        Object target = binder.getTarget();
        Class<?> targetClass = target.getClass();
        if (!replaceMap.containsKey(targetClass)) {
            Map<String, String> mapping = analyzeClass(targetClass);
            replaceMap.put(targetClass, mapping);
        }
        Map<String, String> mapping = replaceMap.get(targetClass);
        RequestParamsDataBinder requestParamsDataBinder = new RequestParamsDataBinder(target, binder.getObjectName(), mapping);
        requestMappingHandlerAdapter.getWebBindingInitializer().initBinder(requestParamsDataBinder, nativeWebRequest);
        super.bindRequestParameters(requestParamsDataBinder, nativeWebRequest);
    }

	/**
	 * Analyze target class by its declared fields and methods and
	 * return the renamed map.
	 *
	 * @param targetClass the target class
	 * @return
	 */
    protected Map<String, String> analyzeClass(Class<?> targetClass) {
        Map<String, String> renameMap = new HashMap<String, String>();
        analyzeClassByFields(targetClass, renameMap);
        analyzeClassByMethods(targetClass, renameMap);
        if (renameMap.isEmpty()) return Collections.emptyMap();
        return renameMap;
    }

    /**
     * Analyze target class by its declared fields and add to the renamed map.
     *
     * @param targetClass the target class
     * @param renameMap the map that contains the renamed fields
     * @return
     */
    protected void analyzeClassByFields(Class<?> targetClass, Map<String, String> renameMap) {
        Field[] fields = targetClass.getDeclaredFields();
        for (Field field : fields) {
        	renameMap.put(propertyNamingStrategyBase.translate(field.getName()), field.getName());
        }
    }

    /**
     * Analyze target class by its declared methods and add to the renamed map.
     *
     * @param targetClass the target class
     * @param renameMap the map that contains the renamed fields
     * @return
     */
	protected void analyzeClassByMethods(Class<?> targetClass, Map<String, String> renameMap) {
        Method[] methods = targetClass.getDeclaredMethods();
        for (Method method : methods) {
        	try {
	        	String fieldName = ReflectionUtils.findFieldFromMethod(targetClass, method).getName();
	        	renameMap.put(propertyNamingStrategyBase.translate(fieldName), fieldName);
        	} catch (NoSuchFieldException e) {}
        }
    }

    /**
     * RequestParamsDataBinder which supports fields renaming using {@link RequestParams @RequestParams}
     */
    class RequestParamsDataBinder extends ExtendedServletRequestDataBinder {

        private final Map<String, String> renameMapping;

        public RequestParamsDataBinder(Object target, String objectName, Map<String, String> renameMapping) {
            super(target, objectName);
            this.renameMapping = renameMapping;
        }

        @Override
        protected void addBindValues(MutablePropertyValues mpvs, ServletRequest request) {
            super.addBindValues(mpvs, request);
            for (Map.Entry<String, String> entry : renameMapping.entrySet()) {
                String from = entry.getKey();
                String to = entry.getValue();
                if (mpvs.contains(from)) {
                    mpvs.add(to, mpvs.getPropertyValue(from).getValue());
                }
            }
        }
    }

    /**
     * Set custom strategy used for the renaming of properties. The PropertyNamingStrategyBase
     * is specified using {@link PropertyNamingStrategy Jackson's PropertyNamingStrategy}.
     *
     *
 Default PropertyNamingStrategyBase is LowerCaseWithUnderscoresStrategy.

     *
     * @param propertyNamingStrategyBase the strategy for the naming of properties
     */
	public void setPropertyNamingStrategyBase(
			PropertyNamingStrategyBase propertyNamingStrategyBase) {
		this.propertyNamingStrategyBase = propertyNamingStrategyBase;
	}

    /**
     * Performs full validation on the request params object if {@link Valid @Valid} is present.
     *
     *

     * Performs partial validation on the request params object if {@link PartialValid @PartialValid}
     * is present. Only field(s) that are not null are validated.
     *

     */
    @Override
	protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) {
		if (parameter.hasParameterAnnotation(PartialValid.class)) {
			Object hints = AnnotationUtils.getValue(parameter.getParameterAnnotation(PartialValid.class));
			partialValidate(binder, hints instanceof Object[] ? (Object[]) hints : new Object[] {hints});
		} else {
			super.validateIfApplicable(binder, parameter);
		}
	}

    /**
     * Performs partial validation by only validating field(s) that are not null.
     *
     * @param binder the data binder instance to use for the binding
     * @param validationHints one or more hint objects to be passed to a {@link SmartValidator}
     */
    protected void partialValidate(WebDataBinder binder, Object... validationHints) {
		Object target = binder.getTarget();
		BindingResult binderBindingResult = binder.getBindingResult();
		BindingResult bindingResult = new BeanPropertyBindingResult(target, binderBindingResult.getObjectName());
		for (Validator validator : binder.getValidators()) {
			if (!ObjectUtils.isEmpty(validationHints) && validator instanceof SmartValidator) {
				((SmartValidator) validator).validate(target, bindingResult, validationHints);
			}
			else if (validator != null) {
				validator.validate(target, bindingResult);
			}
		}
		for (FieldError fieldError: bindingResult.getFieldErrors()) {
			if (!fieldError.getCode().equals(NotNull.class.getSimpleName())) {
				binderBindingResult.addError(fieldError);
			}
		}
    }

	/**
	 * Returns {@code CHECK_INHERIT} if value is null. This is to allow the conversion of
	 * of the target class to its subclass in method {@code createAttributeFromRequestValue()}
	 * if needed.
	 */
	@Override
	protected String getRequestValueForAttribute(String attributeName,
			NativeWebRequest request) {
		String value = super.getRequestValueForAttribute(attributeName, request);
		if (value == null) {
			value = "CHECK_INHERIT";
		}
		return value;
	}

	/**
	 * Converts target object to its subclass if {@link Inheritance @Inherit} is present.
	 * The subclass is specified by value of request parameter "type".
	 */
	@Override
	protected Object createAttributeFromRequestValue(String sourceValue,
			String attributeName, MethodParameter parameter,
			WebDataBinderFactory binderFactory, NativeWebRequest request)
			throws Exception {
		if (sourceValue.equals("CHECK_INHERIT")) {
			return createInheritAttribute(parameter, request);
		} else {
			return super.createAttributeFromRequestValue(sourceValue, attributeName,
					parameter, binderFactory, request);
		}
	}

	/**
	 * Creates an attribute object of the subclass of the target object.
	 * The subclass is specified by value of the request parameter "type".
	 *
	 * @param parameter the parameter that contains the target object
	 * @param request the request that contains the request parameter "type"
	 * @return an attribute object of the specified subclass
	 * @throws BeanInstantiationException
	 * @throws ClassNotFoundException
	 */
	protected Object createInheritAttribute(MethodParameter parameter, NativeWebRequest request)
			throws InheritanceNotFoundException {
		if (!parameter.hasParameterAnnotation(Inheritance.class)) {
			return null;
		}
		String value = parameter.getParameterAnnotation(Inheritance.class).value();
		String type = request.getParameter(value);
		Class<?> superClass = parameter.getParameterType();
		String name = StringUtils.capitalize(type);
		try {
			Class<?> subClass = ReflectionUtils.findSubClassByName(superClass, name);
			return BeanUtils.instantiate(subClass);
		} catch (Exception e) {
			throw new InheritanceNotFoundException(type);
		}
	}
}


text:
phpunit --filter @false.* ../../_files/DataProviderFilterTest.php
--FILE--
<?php declare(strict_types=1);
$_SERVER['argv'][] = '--do-not-cache-result';
$_SERVER['argv'][] = '--no-configuration';
$_SERVER['argv'][] = '--filter';
$_SERVER['argv'][] = '@false.*';
$_SERVER['argv'][] = __DIR__ . '/../../_files/DataProviderFilterTest.php';

require_once __DIR__ . '/../../bootstrap.php';
PHPUnit\TextUI\Application::main();
--EXPECTF--
PHPUnit %s by Sebastian Bergmann and contributors.

Runtime: %s

..                                                                  2 / 2 (100%)

Time: %s, Memory: %s

OK (2 tests, 2 assertions)


text:
require_relative 'common'
require_relative 'mitm_server'
require 'fileutils'
require 'tmpdir'

require 'net/ssh'

require 'timeout'

# see Vagrantfile,playbook for env.
# we're running as net_ssh_1 user password foo
# and usually connecting to net_ssh_2 user password foo2pwd
class TestHMacEtm < NetSSHTest
  include IntegrationTestHelpers

  variants = {
    etm256: "hmac-sha2-256-etm@openssh.com",
    etm512: "hmac-sha2-512-etm@openssh.com"
  }

  def config_with_macs(macs)
    config_lines = File.read('/etc/ssh/sshd_config').split("\n")
    config_lines = config_lines.map do |line|
      if line =~ /^MACs/
        "##{line}"
      else
        line
      end
    end
    config_lines.push("MACs #{macs}")
  end

  variants.each do |key, variant|
    define_method "test_with_only_hmac_etm#{key}" do
      start_sshd_7_or_later(config: config_with_macs(variant)) do |_pid, port|
        Timeout.timeout(4) do
          # We have our own sshd, give it a chance to come up before
          # listening.
          ret = Net::SSH.start(
            "localhost",
            "net_ssh_1",
            password: 'foopwd',
            port: port,
            hmac: [variant]
          ) do |ssh|
            assert_equal ssh.transport.algorithms.hmac_client, variant
            assert_equal ssh.transport.algorithms.hmac_server, variant
            ssh.exec! "echo 'foo123'"
          end
          assert_equal "foo123\n", ret
        rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
          sleep 0.25
          retry
        end
      end
    end
  end

  variants.each do |key, variant|
    define_method "test_hmac_through_proxy_#{key}" do
      mitm = MitmServer.new('localhost', 22)

      mitm.local_read_size = 2 * 1024
      mitm.target_read_size = 19

      mitm.run

      # host, port = 'localhost', 22
      host = mitm.host
      port = mitm.port

      hmac_options = { hmac: variant }
      ssh = Net::SSH.start(host, "net_ssh_1", hmac_options.merge(port: port, password: 'foopwd'))
      (1...20).each do |i|
        ret = ssh.exec!("echo \"#{'f' * i}\"")
        assert_includes ret, 'f' * i
      end
      ssh.close
    end
  end
end


text:
namespace {
  void printTiming(const char* type, int steps, double tol, double time) {
    if (!PCU_Comm_Self())
      parmaCommons::status("%s balanced in %d steps to %f in %f seconds\n",
          type, steps, tol, time);
  }
}

namespace parma {
  Balancer::Balancer(apf::Mesh* m, double f, int v, const char* n)
    : mesh(m), factor(f), verbose(v), name(n) {
      maxStep = 300;
      iS = new parma::Slope();
      iA = new parma::Average(8);
      sS = new parma::Slope();
      sA = new parma::Average(8);
  }
  Balancer::~Balancer() {
    delete iA;
    delete iS;
    delete sA;
    delete sS;
    apf::MeshTag* dist = parma::getDistTag(mesh);
    if(dist) {
      apf::removeTagFromDimension(mesh,dist,0);
      mesh->destroyTag(dist);
    }
  }
  void Balancer::balance(apf::MeshTag* wtag, double tolerance) {
    if( 1 == PCU_Comm_Peers() ) return;
    int step = 0;
    double t0 = PCU_Time();
    while (runStep(wtag,tolerance) && step++ < maxStep);
    printTiming(name, step, tolerance, PCU_Time()-t0);
  }
  void Balancer::monitorUpdate(double v, Slope* s, Average* a) {
    s->push(v);
    const double slope = (s->full()) ? s->slope() : 1.0;
    a->push(slope);
  }
}


text:
package com.example.roadkings;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import com.example.Database.DatabaseClass;
import com.example.Database.RepairHistory;

import android.os.AsyncTask;
import android.os.Bundle;
import android.app.Activity;
import android.app.ProgressDialog;
import android.view.Menu;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.SimpleAdapter;

public class DisplayRepairHistory extends Activity {

	DatabaseClass databaseClass;
	ProgressDialog progressDialog = null;
	private static String imageRepairKey  = "imageRepair";
	private static String problemKey = "problem";
	private static String dateRepairKey = "dateRepair";
	private static String repairPartKey = "partsRepair";
	private ListView listView;
	ArrayList<HashMap<String, String>> repairList = new ArrayList<HashMap<String,String>>();
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_display_repair_history);
		databaseClass  = new DatabaseClass(getApplicationContext());

		listView = (ListView)findViewById(R.id.listViewRepair);
		new GetRepairDetails().execute(databaseClass);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.display_repair_history, menu);
		return true;
	}

	@Override
	protected void onStart() {
		super.onStart();

	}

	class GetRepairDetails extends AsyncTask<DatabaseClass, Void, Void>{

		@Override
		protected void onPreExecute() {
			// TODO Auto-generated method stub
			super.onPreExecute();
/*			progressDialog = new ProgressDialog(this);
			progressDialog.setMessage("Please Wait..");
			progressDialog.setCancelable(false);
			progressDialog.show();*/

		}
		@Override
		protected Void doInBackground(DatabaseClass... params) {
			// TODO Auto-generated method stub

			List<RepairHistory> histories = databaseClass.getAllRecords();
			if(histories!=null)
			{

				for(RepairHistory history: histories)
				{
					HashMap<String, String> repairHistMap = new HashMap<String, String>();
					repairHistMap.put(imageRepairKey, Integer.toString(R.drawable.roadking));
					repairHistMap.put(problemKey, history.getRepair_details());
					repairHistMap.put(dateRepairKey, history.getDate());
					repairHistMap.put(repairPartKey, history.getParts());
					repairList.add(repairHistMap);
				}
				return null;
			}
			else
			{
				System.out.println("records not found");
			}
			return null;

		}

		@Override
		protected void onPostExecute(Void result) {
			// TODO Auto-generated method stub
			super.onPostExecute(result);
			//progressDialog.dismiss();
			runOnUiThread(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					if(!repairList.isEmpty())
					{
						ListAdapter listAdapter = new SimpleAdapter(DisplayRepairHistory.this, repairList, R.layout.repair_items, new String[]{imageRepairKey, problemKey,repairPartKey,dateRepairKey}, new int[]{R.id.imageRepair, R.id.problem,R.id.partsRepair, R.id.dateRepair});
						listView.setAdapter(listAdapter);
					}

				}
			});

		}

	}
}


text:
using System.Linq;
using System.Threading.Tasks;
using Avalonia.Controls;
using Avalonia.Controls.Platform;

namespace Avalonia.Dialogs
{
    public static class ManagedFileDialogExtensions
    {
        private class ManagedSystemDialogImpl<T> : ISystemDialogImpl where T : Window, new()
        {
            async Task<string[]> Show(SystemDialog d, Window parent, ManagedFileDialogOptions options = null)
            {
                var model = new ManagedFileChooserViewModel((FileSystemDialog)d,
                    options ?? new ManagedFileDialogOptions());

                var dialog = new T
                {
                    Content = new ManagedFileChooser(),
                    Title = d.Title,
                    DataContext = model
                };

                dialog.Closed += delegate { model.Cancel(); };

                string[] result = null;

                model.CompleteRequested += items =>
                {
                    result = items;
                    dialog.Close();
                };

                model.CancelRequested += dialog.Close;

                await dialog.ShowDialog<object>(parent);
                return result;
            }

            public async Task<string[]> ShowFileDialogAsync(FileDialog dialog, Window parent)
            {
                return await Show(dialog, parent);
            }

            public async Task<string> ShowFolderDialogAsync(OpenFolderDialog dialog, Window parent)
            {
                return (await Show(dialog, parent))?.FirstOrDefault();
            }

            public async Task<string[]> ShowFileDialogAsync(FileDialog dialog, Window parent, ManagedFileDialogOptions options)
            {
                return await Show(dialog, parent, options);
            }
        }

        public static TAppBuilder UseManagedSystemDialogs<TAppBuilder>(this TAppBuilder builder)
            where TAppBuilder : AppBuilderBase<TAppBuilder>, new()
        {
            builder.AfterSetup(_ =>
                AvaloniaLocator.CurrentMutable.Bind<ISystemDialogImpl>().ToSingleton<ManagedSystemDialogImpl<Window>>());
            return builder;
        }

        public static TAppBuilder UseManagedSystemDialogs<TAppBuilder, TWindow>(this TAppBuilder builder)
            where TAppBuilder : AppBuilderBase<TAppBuilder>, new() where TWindow : Window, new()
        {
            builder.AfterSetup(_ =>
                AvaloniaLocator.CurrentMutable.Bind<ISystemDialogImpl>().ToSingleton<ManagedSystemDialogImpl<TWindow>>());
            return builder;
        }

        public static Task<string[]> ShowManagedAsync(this OpenFileDialog dialog, Window parent,
            ManagedFileDialogOptions options = null) => ShowManagedAsync<Window>(dialog, parent, options);

        public static Task<string[]> ShowManagedAsync<TWindow>(this OpenFileDialog dialog, Window parent,
            ManagedFileDialogOptions options = null) where TWindow : Window, new()
        {
            return new ManagedSystemDialogImpl<TWindow>().ShowFileDialogAsync(dialog, parent, options);
        }
    }
}


text:
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

/**
 * @fileoverview Boostrap for loading javascript/html files using d8_runner.
 */
(function(global, v8arguments) {
  // Save the argv in a predictable and stable location.
  global.sys = {
    argv: []
  };
  for (var i = 0; i < v8arguments.length; i++)
    sys.argv.push(v8arguments[i]);

  /* There are four ways a program can finish running in D8:
   * - a) Intentioned exit triggered via quit(0)
   * - b) Intentioned exit triggered via quit(n)
   * - c) Running to end of the script
   * - d) An uncaught exception
   *
   * The exit code of d8 for case a is 0.
   * The exit code of d8 for case b is unsigned(n) & 0xFF
   * The exit code of d8 for case c is 0.
   * The exit code of d8 for case d is 1.
   *
   * D8 runner needs to distinguish between these cases:
   * - a) _ExecuteFileWithD8 should return 0
   * - b) _ExecuteFileWithD8 should return n
   * - c) _ExecuteFileWithD8 should return 0
   * - d) _ExecuteFileWithD8 should raise an Exception
   *
   * The hard one here is d and b with n=1, because they fight for the same
   * return code.
   *
   * Our solution is to monkeypatch quit() s.t. quit(1) becomes exitcode=2.
   * This makes quit(255) disallowed, but it ensures that D8 runner is able
   * to handle the other cases correctly.
   */
  var realQuit = global.quit;
  global.quit = function(exitCode) {
    // Normalize the exit code.
    if (exitCode < 0) {
      exitCode = (exitCode % 256) + 256;
    } else {
      exitCode = exitCode % 256;
    }

    // 255 is reserved due to reasons noted above.
    if (exitCode == 255)
      throw new Error('exitCodes 255 is reserved, sorry.');
    if (exitCode === 0)
      realQuit(0);
    realQuit(exitCode + 1);
  }

  /**
   * Polyfills console's methods.
   */
  global.console = {
    log: function() {
      var args = Array.prototype.slice.call(arguments);
      print(args.join(' '));
    },

    info: function() {
      var args = Array.prototype.slice.call(arguments);
      print('Info:', args.join(' '));
    },

    error: function() {
      var args = Array.prototype.slice.call(arguments);
      print('Error:', args.join(' '));
    },

    warn: function() {
      var args = Array.prototype.slice.call(arguments);
      print('Warning:', args.join(' '));
    }
  };

  if (os.chdir) {
    os.chdir = function() {
      throw new Error('Dont do this');
    }
  }

  /* This is a Base64 Polyfill adapted from
   * https://github.com/davidchambers/Base64.js/blob/0.3.0/,
   * which has a "do whatever you want" license,
   * https://github.com/davidchambers/Base64.js/blob/0.3.0/LICENSE.
   */
  (function() {
    var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' +
        '0123456789+/=';

    function InvalidCharacterError(message) {
      this.message = message;
    }
    InvalidCharacterError.prototype = new Error;
    InvalidCharacterError.prototype.name = 'InvalidCharacterError';

    // encoder
    // [https://gist.github.com/999166] by [https://github.com/nignag]
    global.btoa = function(input) {
      var str = String(input);
      for (
          // Initialize result and counter.
          var block, charCode, idx = 0, map = chars, output = '';
          // If the next str index does not exist:
          //   change the mapping table to "="
          //   check if d has no fractional digits
          str.charAt(idx | 0) || (map = '=', idx % 1);
          // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8.
          output += map.charAt(63 & block >> 8 - idx % 1 * 8)) {
        charCode = str.charCodeAt(idx += 3 / 4);
        if (charCode > 0xFF) {
          throw new InvalidCharacterError(
              '\'btoa\' failed: The string to be encoded contains characters ' +
              'outside of the Latin1 range.');
        }
        block = block << 8 | charCode;
      }
      return output;
    };

    // decoder
    // [https://gist.github.com/1020396] by [https://github.com/atk]
    global.atob = function(input) {
      var str = String(input).replace(/=+$/, '');
      if (str.length % 4 == 1) {
        throw new InvalidCharacterError(
            '\'atob\' failed: The string to be decoded is not ' +
            'correctly encoded.');
      }
      for (
          // Initialize result and counters.
          var bc = 0, bs, buffer, idx = 0, output = '';
          // Get next character.
          buffer = str.charAt(idx++);
          // Character found in table? initialize bit storage and add its
          // ascii value;
          ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,
              // And if not first of each 4 characters,
              // convert the first 8 bits to one ascii character.
              bc++ % 4) ? output += String.fromCharCode(
                    255 & bs >> (-2 * bc & 6)) : 0) {
        // Try to find character in table (0-63, not found => -1).
        buffer = chars.indexOf(buffer);
      }
      return output;
    };

  })();

  // Bring in html_to_js_generator.
  global.path_to_js_parser = '<%js_parser_path%>';
  load('<%html_to_js_generator_js_path%>');

  // Bring in path utils.
  load('<%path_utils_js_path%>');

  var d8_path_utils = new PathUtils(
      {
        currentWorkingDirectory: '<%current_working_directory%>',
        exists: function(fileName) {
          try {
            // Try a dummy read to check whether file_path exists.
            // TODO(nednguyen): find a more efficient way to check whether
            // some file path exists in d8.
            read(fileName);
            return true;
          } catch (err) {
            return false;
          }
        }
      });

  /**
   * Strips the starting '/' in file_path if |file_path| is meant to be a
   * relative path.
   *
   * @param {string} file_path path to some file, can be relative or absolute
   * path.
   * @return {string} the file_path with starting '/' removed if |file_path|
   * does not exist or the original |file_path| otherwise.
   */
  function _stripStartingSlashIfNeeded(file_path) {
    if (file_path.substring(0, 1) !== '/') {
      return file_path;
    }
    if (d8_path_utils.exists(file_path))
      return file_path;
    return file_path.substring(1);
  }

  var sourcePaths = JSON.parse('<%source_paths%>');

  global.hrefToAbsolutePath = function(href) {
    var pathPart;
    if (!d8_path_utils.isAbs(href)) {
      throw new Error('Found a non absolute import and thats not supported: ' +
                      href);
    } else {
      pathPart = href.substring(1);
    }

    candidates = [];
    for (var i = 0; i < sourcePaths.length; i++) {
      var candidate = d8_path_utils.join(sourcePaths[i], pathPart);
      if (d8_path_utils.exists(candidate))
        candidates.push(candidate);
    }
    if (candidates.length > 1)
      throw new Error('Multiple candidates found for ' + href);
    if (candidates.length === 0)
      throw new Error(href + ' not found!');
    return candidates[0];
  }

  var loadedModulesByFilePath = {};

  /**
   * Load a HTML file, which absolute path or path relative to <%search-path%>.
   * Unlike the native load() method of d8, variables declared in |file_path|
   * will not be hoisted to the caller environment. For example:
   *
   * a.html:
   * <script>
   *   var x = 1;
   * </script>
   *
   * test.js:
   * loadHTML("a.html");
   * print(x);  // <- ReferenceError is thrown because x is not defined.
   *
   * @param {string} file_path path to the HTML file to be loaded.
   */
  global.loadHTML = function(href) {
    var absPath = global.hrefToAbsolutePath(href);
    global.loadHTMLFile(absPath, href);
  };

  global.loadScript = function(href) {
    var absPath = global.hrefToAbsolutePath(href);
    global.loadFile(absPath, href);
  };

  global.loadHTMLFile = function(absPath, opt_href) {
    var href = opt_href || absPath;
    if (loadedModulesByFilePath[absPath])
      return;
    loadedModulesByFilePath[absPath] = true;

    try {
      var html_content = read(absPath);
    } catch (err) {
      throw new Error('Error in loading html file ' + href +
          ': File does not exist');
    }

    try {
      var stripped_js = generateJsFromHTML(html_content);
    } catch (err) {
      throw new Error('Error in loading html file ' + href + ': ' + err);
    }

    // Add "//@ sourceURL=|file_path|" to the end of generated js to preserve
    // the line numbers
    stripped_js = stripped_js + '\n//@ sourceURL=' + href;
    eval(stripped_js);
  };

  global.loadFile = function(absPath, opt_href) {
    var href = opt_href || absPath;
    var relPath = d8_path_utils.relPath(absPath);
    try {
      load(relPath);
    } catch (err) {
      throw new Error('Error in loading script file ' + href + ': ' + err);
    }
  };
})(this, arguments);


text:
Metadata
========

.. java:package:: hlt
   :noindex:

.. java:type:: public class Metadata

Constructors
------------
Metadata
^^^^^^^^

.. java:constructor:: public Metadata(String[] metadata)
   :outertype: Metadata

Methods
-------
isEmpty
^^^^^^^

.. java:method:: public boolean isEmpty()
   :outertype: Metadata

pop
^^^

.. java:method:: public String pop()
   :outertype: Metadata


text:
/**
 * Auto-configuration for RabbitMQ metrics.
 */
package org.springframework.boot.actuate.autoconfigure.metrics.amqp;


text:
external help file: Microsoft.Azure.Commands.HDInsight.dll-Help.xml
Module Name: AzureRM.HDInsight
ms.assetid: 08D1D6AC-D064-4E2D-9C22-0B65E7BE4DA7
online version: https://docs.microsoft.com/en-us/powershell/module/azurerm.hdinsight/remove-azurermhdinsightpersistedscriptaction
schema: 2.0.0
---

# Remove-AzureRmHDInsightPersistedScriptAction

## SYNOPSIS
Removes an persisted script action from an HDInsight cluster.

## SYNTAX

```
Remove-AzureRmHDInsightPersistedScriptAction [-ClusterName] <String> [-Name] <String>
 [-ResourceGroupName <String>] [-DefaultProfile <IAzureContextContainer>] [<CommonParameters>]
```

## DESCRIPTION
The **Remove-AzureRmHDInsightPersistedScriptAction** cmdlet removes a persisted script action from the specified Azure HDInsight cluster's list of persisted script actions.
The removed script will no longer be executed when the cluster is scaled up.

## EXAMPLES

### Example 1: Remove a script action from the list of persisted script actions on a cluster
```
PS C:\>Remove-AzureRmHDInsightPersistedScriptAction `
            -ClusterName "your-hadoop-001" `
            -Name "Scriptaction"
```

This command removes the script action named Scriptaction from the list of persisted script actions on the specified cluster.

## PARAMETERS

### -ClusterName
Specifies the name of the cluster.

```yaml
Type: System.String
Parameter Sets: (All)
Aliases:

Required: True
Position: 0
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -DefaultProfile
The credentials, account, tenant, and subscription used for communication with azure

```yaml
Type: Microsoft.Azure.Commands.Common.Authentication.Abstractions.IAzureContextContainer
Parameter Sets: (All)
Aliases: AzureRmContext, AzureCredential

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Name
Specifies the name of the persisted script action to be removed.

```yaml
Type: System.String
Parameter Sets: (All)
Aliases:

Required: True
Position: 1
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -ResourceGroupName
Specifies the name of the resource group.

```yaml
Type: System.String
Parameter Sets: (All)
Aliases:

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### CommonParameters
This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see about_CommonParameters (http://go.microsoft.com/fwlink/?LinkID=113216).

## INPUTS

### None

## OUTPUTS

### System.Void

## NOTES

## RELATED LINKS

[Get-AzureRmHDInsightPersistedScriptAction](./Get-AzureRmHDInsightPersistedScriptAction.md)

[Set-AzureRmHDInsightPersistedScriptAction](./Set-AzureRmHDInsightPersistedScriptAction.md)


text:
package nodes

import (
	"fmt"
	"strings"
	"time"

	"github.com/docker/docker/pkg/discovery"
)

// Discovery is exported
type Discovery struct {
	entries discovery.Entries
}

func init() {
	Init()
}

// Init is exported
func Init() {
	discovery.Register("nodes", &Discovery{})
}

// Initialize is exported
func (s *Discovery) Initialize(uris string, _ time.Duration, _ time.Duration, _ map[string]string) error {
	for _, input := range strings.Split(uris, ",") {
		for _, ip := range discovery.Generate(input) {
			entry, err := discovery.NewEntry(ip)
			if err != nil {
				return fmt.Errorf("%s, please check you are using the correct discovery (missing token:// ?)", err.Error())
			}
			s.entries = append(s.entries, entry)
		}
	}

	return nil
}

// Watch is exported
func (s *Discovery) Watch(stopCh <-chan struct{}) (<-chan discovery.Entries, <-chan error) {
	ch := make(chan discovery.Entries)
	go func() {
		defer close(ch)
		ch <- s.entries
		<-stopCh
	}()
	return ch, nil
}

// Register is exported
func (s *Discovery) Register(addr string) error {
	return discovery.ErrNotImplemented
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
Runner (JUnit API)
</TITLE>

<META NAME="keywords" CONTENT="org.junit.runner.Runner class">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../stylesheet.css" TITLE="Style">

      Overview
      Package
    Class
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.junit.runner

Class Runner

java.lang.Object
  org.junit.runner.Runner

Direct Known Subclasses:
org.junit.internal.runners.CompositeRunner, org.junit.internal.runners.JUnit38ClassRunner

public abstract class Runner
extends java.lang.Object

A Runner runs tests and notifies a RunNotifier
 of significant events as it does so. You will need to subclass Runner
 when using RunWith to invoke a custom runner. When creating
 a custom runner, in addition to implementing the abstract methods here you must
 also provide a constructor that takes as an argument the Class containing
 the tests.

 The default runner implementation guarantees that the instances of the test case
 class will be constructed immediately before running the test and that the runner
 will retain no reference to the test case instances, generally making them
 available for garbage collection.

See Also:
Description,
RunWith

Constructor Summary

Runner()

Method Summary

abstract  Description
getDescription()

abstract  void
run(RunNotifier notifier)

          Run the tests for this runner.

 int
testCount()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Runner

public Runner()

Method Detail

getDescription

public abstract Description getDescription()

Returns:
a Description showing the tests to be run by the receiver

run

public abstract void run(RunNotifier notifier)

Run the tests for this runner.

Parameters:
notifier - will be notified of events while tests are being run--tests being
 started, finishing, and failing

testCount

public int testCount()

Returns:
the number of tests to be run by the receiver

      Overview
      Package
    Class
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD


text:
var win = Ti.UI.createWindow({
	backgroundColor:'white'
});
var label = Ti.UI.createLabel();
win.add(label);
win.open();

// TODO: write your module tests here
var ios7media = require('jptech.ios7media');
Ti.API.info("module is => " + ios7media);

label.text = ios7media.example();

Ti.API.info("module exampleProp is => " + ios7media.exampleProp);
ios7media.exampleProp = "This is a test value";

if (Ti.Platform.name == "android") {
	var proxy = ios7media.createExample({
		message: "Creating an example Proxy",
		backgroundColor: "red",
		width: 100,
		height: 100,
		top: 100,
		left: 150
	});

	proxy.printMessage("Hello world!");
	proxy.message = "Hi world!.  It's me again.";
	proxy.printMessage("Hello world!");
	win.add(proxy);
}


text:
require File.expand_path('../../../spec_helper', __FILE__)

describe FreeMusicArchive::Client do

  before do
    @client = FreeMusicArchive::Client.new()
  end

  describe ".artists" do

    before do
      stub_get("/api/get/artists.xml").
        to_return(:body => fixture("artists.xml"), :headers => {:content_type => "application/xml; charset=utf-8"})
    end

    it "should get the correct resource" do
      @client.artists()
      a_get("/api/get/artists.xml").should have_been_made
    end

    it "should have a title of artists" do
      response = @client.artists()
      response.title.should == "Free Music Archive - Artists"
    end

    it "should return an array of artists" do
      response = @client.artists()
      response.dataset.value.should be_an Array
      response.dataset.value.first["artist_id"].should == "365"
    end

  end
end


text:
namespace HandyQuery.Language.Lexing
{
    internal readonly ref struct RelativePositionInfo
    {
        public readonly int Line;
        public readonly int Column;

        public RelativePositionInfo(int line, int column)
        {
            Line = line;
            Column = column;
        }
    }
}


text:
package validation

import (
	"encoding/json"
	"fmt"
	"reflect"
	"regexp"
	"strings"

	"github.com/emicklei/go-restful/swagger"
	"github.com/golang/glog"
	apiutil "k8s.io/kubernetes/pkg/api/util"
	utilerrors "k8s.io/kubernetes/pkg/util/errors"
	"k8s.io/kubernetes/pkg/util/validation"
	"k8s.io/kubernetes/pkg/util/yaml"
)

type InvalidTypeError struct {
	ExpectedKind reflect.Kind
	ObservedKind reflect.Kind
	FieldName    string
}

func (i *InvalidTypeError) Error() string {
	return fmt.Sprintf("expected type %s, for field %s, got %s", i.ExpectedKind.String(), i.FieldName, i.ObservedKind.String())
}

func NewInvalidTypeError(expected reflect.Kind, observed reflect.Kind, fieldName string) error {
	return &InvalidTypeError{expected, observed, fieldName}
}

// Schema is an interface that knows how to validate an API object serialized to a byte array.
type Schema interface {
	ValidateBytes(data []byte) error
}

type NullSchema struct{}

func (NullSchema) ValidateBytes(data []byte) error { return nil }

type SwaggerSchema struct {
	api swagger.ApiDeclaration
}

func NewSwaggerSchemaFromBytes(data []byte) (Schema, error) {
	schema := &SwaggerSchema{}
	err := json.Unmarshal(data, &schema.api)
	if err != nil {
		return nil, err
	}
	return schema, nil
}

// validateList unpack a list and validate every item in the list.
// It return nil if every item is ok.
// Otherwise it return an error list contain errors of every item.
func (s *SwaggerSchema) validateList(obj map[string]interface{}) validation.ErrorList {
	allErrs := validation.ErrorList{}
	items, exists := obj["items"]
	if !exists {
		return append(allErrs, fmt.Errorf("no items field in %#v", obj))
	}
	itemList, ok := items.([]interface{})
	if !ok {
		return append(allErrs, fmt.Errorf("items isn't a slice"))
	}
	for i, item := range itemList {
		fields, ok := item.(map[string]interface{})
		if !ok {
			allErrs = append(allErrs, fmt.Errorf("items[%d] isn't a map[string]interface{}", i))
			continue
		}
		groupVersion := fields["apiVersion"]
		if groupVersion == nil {
			allErrs = append(allErrs, fmt.Errorf("items[%d].apiVersion not set", i))
			continue
		}
		itemVersion, ok := groupVersion.(string)
		if !ok {
			allErrs = append(allErrs, fmt.Errorf("items[%d].apiVersion isn't string type", i))
			continue
		}
		if len(itemVersion) == 0 {
			allErrs = append(allErrs, fmt.Errorf("items[%d].apiVersion is empty", i))
		}
		kind := fields["kind"]
		if kind == nil {
			allErrs = append(allErrs, fmt.Errorf("items[%d].kind not set", i))
			continue
		}
		itemKind, ok := kind.(string)
		if !ok {
			allErrs = append(allErrs, fmt.Errorf("items[%d].kind isn't string type", i))
			continue
		}
		if len(itemKind) == 0 {
			allErrs = append(allErrs, fmt.Errorf("items[%d].kind is empty", i))
		}
		version := apiutil.GetVersion(itemVersion)
		errs := s.ValidateObject(item, "", version+"."+itemKind)
		if len(errs) >= 1 {
			allErrs = append(allErrs, errs...)
		}
	}
	return allErrs
}

func (s *SwaggerSchema) ValidateBytes(data []byte) error {
	var obj interface{}
	out, err := yaml.ToJSON(data)
	if err != nil {
		return err
	}
	data = out
	if err := json.Unmarshal(data, &obj); err != nil {
		return err
	}
	fields, ok := obj.(map[string]interface{})
	if !ok {
		return fmt.Errorf("error in unmarshaling data %s", string(data))
	}
	groupVersion := fields["apiVersion"]
	if groupVersion == nil {
		return fmt.Errorf("apiVersion not set")
	}
	if _, ok := groupVersion.(string); !ok {
		return fmt.Errorf("apiVersion isn't string type")
	}
	kind := fields["kind"]
	if kind == nil {
		return fmt.Errorf("kind not set")
	}
	if _, ok := kind.(string); !ok {
		return fmt.Errorf("kind isn't string type")
	}
	if strings.HasSuffix(kind.(string), "List") {
		return utilerrors.NewAggregate(s.validateList(fields))
	}
	version := apiutil.GetVersion(groupVersion.(string))
	allErrs := s.ValidateObject(obj, "", version+"."+kind.(string))
	if len(allErrs) == 1 {
		return allErrs[0]
	}
	return utilerrors.NewAggregate(allErrs)
}

func (s *SwaggerSchema) ValidateObject(obj interface{}, fieldName, typeName string) validation.ErrorList {
	allErrs := validation.ErrorList{}
	models := s.api.Models
	model, ok := models.At(typeName)
	if !ok {
		return append(allErrs, fmt.Errorf("couldn't find type: %s", typeName))
	}
	properties := model.Properties
	if len(properties.List) == 0 {
		// The object does not have any sub-fields.
		return nil
	}
	fields, ok := obj.(map[string]interface{})
	if !ok {
		return append(allErrs, fmt.Errorf("field %s: expected object of type map[string]interface{}, but the actual type is %T", fieldName, obj))
	}
	if len(fieldName) > 0 {
		fieldName = fieldName + "."
	}
	// handle required fields
	for _, requiredKey := range model.Required {
		if _, ok := fields[requiredKey]; !ok {
			allErrs = append(allErrs, fmt.Errorf("field %s: is required", requiredKey))
		}
	}
	for key, value := range fields {
		details, ok := properties.At(key)
		if !ok {
			allErrs = append(allErrs, fmt.Errorf("found invalid field %s for %s", key, typeName))
			continue
		}
		if details.Type == nil && details.Ref == nil {
			allErrs = append(allErrs, fmt.Errorf("could not find the type of %s from object: %v", key, details))
		}
		var fieldType string
		if details.Type != nil {
			fieldType = *details.Type
		} else {
			fieldType = *details.Ref
		}
		if value == nil {
			glog.V(2).Infof("Skipping nil field: %s", key)
			continue
		}
		errs := s.validateField(value, fieldName+key, fieldType, &details)
		if len(errs) > 0 {
			allErrs = append(allErrs, errs...)
		}
	}
	return allErrs
}

// This matches type name in the swagger spec, such as "v1.Binding".
var versionRegexp = regexp.MustCompile(`^v.+\..*`)

func (s *SwaggerSchema) validateField(value interface{}, fieldName, fieldType string, fieldDetails *swagger.ModelProperty) validation.ErrorList {
	// TODO: caesarxuchao: because we have multiple group/versions and objects
	// may reference objects in other group, the commented out way of checking
	// if a filedType is a type defined by us is outdated. We use a hacky way
	// for now.
	// TODO: the type name in the swagger spec is something like "v1.Binding",
	// and the "v1" is generated from the package name, not the groupVersion of
	// the type. We need to fix go-restful to embed the group name in the type
	// name, otherwise we couldn't handle identically named types in different
	// groups correctly.
	if versionRegexp.MatchString(fieldType) {
		// if strings.HasPrefix(fieldType, apiVersion) {
		return s.ValidateObject(value, fieldName, fieldType)
	}
	allErrs := validation.ErrorList{}
	switch fieldType {
	case "string":
		// Be loose about what we accept for 'string' since we use IntOrString in a couple of places
		_, isString := value.(string)
		_, isNumber := value.(float64)
		_, isInteger := value.(int)
		if !isString && !isNumber && !isInteger {
			return append(allErrs, NewInvalidTypeError(reflect.String, reflect.TypeOf(value).Kind(), fieldName))
		}
	case "array":
		arr, ok := value.([]interface{})
		if !ok {
			return append(allErrs, NewInvalidTypeError(reflect.Array, reflect.TypeOf(value).Kind(), fieldName))
		}
		var arrType string
		if fieldDetails.Items.Ref == nil && fieldDetails.Items.Type == nil {
			return append(allErrs, NewInvalidTypeError(reflect.Array, reflect.TypeOf(value).Kind(), fieldName))
		}
		if fieldDetails.Items.Ref != nil {
			arrType = *fieldDetails.Items.Ref
		} else {
			arrType = *fieldDetails.Items.Type
		}
		for ix := range arr {
			errs := s.validateField(arr[ix], fmt.Sprintf("%s[%d]", fieldName, ix), arrType, nil)
			if len(errs) > 0 {
				allErrs = append(allErrs, errs...)
			}
		}
	case "uint64":
	case "int64":
	case "integer":
		_, isNumber := value.(float64)
		_, isInteger := value.(int)
		if !isNumber && !isInteger {
			return append(allErrs, NewInvalidTypeError(reflect.Int, reflect.TypeOf(value).Kind(), fieldName))
		}
	case "float64":
		if _, ok := value.(float64); !ok {
			return append(allErrs, NewInvalidTypeError(reflect.Float64, reflect.TypeOf(value).Kind(), fieldName))
		}
	case "boolean":
		if _, ok := value.(bool); !ok {
			return append(allErrs, NewInvalidTypeError(reflect.Bool, reflect.TypeOf(value).Kind(), fieldName))
		}
	case "any":
	default:
		return append(allErrs, fmt.Errorf("unexpected type: %v", fieldType))
	}
	return allErrs
}


text:
<!DOCTYPE html>

        <meta charset="UTF-8" />
        <meta name="robots" content="index, follow, all" />
        <title>Thelia\Core\Event\Brand | </title>
                    <link rel="stylesheet" type="text/css" href="../../../stylesheet.css">

Classes

Namespaces

Interfaces

Traits

Index

Namespace

Thelia\Core\Event\Brand

                    BrandCreateEvent
                    Class BrandCreateEvent

                    BrandDeleteEvent
                    Class BrandDeleteEvent

                    BrandEvent
                    Class BrandEvent

                    BrandToggleVisibilityEvent
                    Class BrandToggleVisibilityEvent

                    BrandUpdateEvent
                    Class BrandUpdateEvent

        Generated by Sami, the API Documentation Generator.