text:
/* VRPhysicsEnableCollisions
 * MiddleVR
 * (c) MiddleVR
 */

using UnityEngine;
using System;
using System.Collections;
using MiddleVR_Unity3D;

[AddComponentMenu("MiddleVR/Physics/Enable Collisions")]
[RequireComponent(typeof(VRPhysicsBody))]
public class VRPhysicsEnableCollisions : MonoBehaviour {

    #region Member Variables

    [SerializeField]
    private GameObject m_ConnectedBody = null;

    private bool m_InitialActionProcessed = false;

    #endregion

    #region Member Properties

    public GameObject ConnectedBody
    {
        get
        {
            return m_ConnectedBody;
        }

        set
        {
            m_ConnectedBody = value;
        }
    }

    #endregion

    #region MonoBehaviour Member Functions

    protected void Start()
    {
        if (MiddleVR.VRClusterMgr.IsCluster() && !MiddleVR.VRClusterMgr.IsServer())
        {
            enabled = false;
            return;
        }

        if (MiddleVR.VRPhysicsMgr == null)
        {
            MiddleVRTools.Log(0, "[X] PhysicsEnableCollisions: No PhysicsManager found.");
            enabled = false;

            return;
        }

        vrPhysicsEngine physicsEngine = MiddleVR.VRPhysicsMgr.GetPhysicsEngine();

        if (physicsEngine == null)
        {
            MiddleVRTools.Log(0, "[X] PhysicsEnableCollisions: No PhysicsEngine found.");
            enabled = false;

            return;
        }
    }

    protected void OnEnable()
    {
        if (m_InitialActionProcessed)
        {
            vrPhysicsBody physicsBody = GetPhysicsBodyInSimulation();

            if (physicsBody != null)
            {
                EnableCollisions(physicsBody, true);
            }
        }
    }

    protected void OnDisable()
    {
        vrPhysicsBody physicsBody = GetPhysicsBodyInSimulation();

        if (physicsBody != null)
        {
            EnableCollisions(physicsBody, false);
        }
    }

    protected void Update()
    {
        if (!m_InitialActionProcessed)
        {
            vrPhysicsBody physicsBody = GetPhysicsBodyInSimulation();

            if (physicsBody != null)
            {
                m_InitialActionProcessed = true;

                EnableCollisions(physicsBody, true);
            }
        }
    }

    #endregion

    #region VRPhysicsEnableCollisions Functions

    protected vrPhysicsBody GetPhysicsBodyInSimulation()
    {
        if (MiddleVR.VRPhysicsMgr == null)
        {
            return null;
        }

        vrPhysicsEngine physicsEngine = MiddleVR.VRPhysicsMgr.GetPhysicsEngine();

        if (physicsEngine == null)
        {
            return null;
        }

        vrPhysicsBody physicsBody = physicsEngine.GetBody(GetComponent<VRPhysicsBody>().PhysicsBodyName);

        if (physicsBody != null && physicsBody.IsInSimulation())
        {
            return physicsBody;
        }
        else
        {
            return null;
        }
    }

    protected void EnableCollisions(vrPhysicsBody physicsBody0, bool iEnabled)
    {
        bool operationDone = false;

        vrPhysicsBody physicsBody1 = null;

        if (m_ConnectedBody != null)
        {
            if (MiddleVR.VRPhysicsMgr == null)
            {
                return;
            }

            vrPhysicsEngine physicsEngine = MiddleVR.VRPhysicsMgr.GetPhysicsEngine();

            if (physicsEngine == null)
            {
                return;
            }

            physicsBody1 = physicsEngine.GetBody(m_ConnectedBody.GetComponent<VRPhysicsBody>().PhysicsBodyName);

            if (physicsBody1 == null)
            {
                MiddleVRTools.Log(0, "[X] PhysicsEnableCollisions: No PhysicsBody found in the connected body.");
                return;
            }

            operationDone = physicsBody0.EnableCollisionsWith(physicsBody1, iEnabled);
        }
        else
        {
            operationDone = physicsBody0.EnableAllCollisions(iEnabled);
        }

        if (operationDone)
        {
            string againstTxt = (physicsBody1 != null ?
                " against object '" + physicsBody1.GetName() + "'" :
                " against the world scene"
                );

            if (iEnabled)
            {
                MiddleVRTools.Log(2, "[ ] PhysicsEnableCollisions: Enabled collisions for '" +
                    physicsBody0.GetName() + "'" + againstTxt + ".");
            }
            else
            {
                MiddleVRTools.Log(2, "[ ] PhysicsEnableCollisions: Disabled collisions for '" +
                    physicsBody0.GetName() + "'" + againstTxt + ".");
            }
        }
        else
        {
            if (iEnabled)
            {
                MiddleVRTools.Log(0, "[X] PhysicsEnableCollisions: Failed to enable collisions for '" +
                    physicsBody0.GetName() + "'.");
            }
            else
            {
                MiddleVRTools.Log(0, "[X] PhysicsEnableCollisions: Failed to disable collisions for '" +
                    physicsBody0.GetName() + "'.");
            }
        }
    }

    #endregion
}


text:
using System;
using System.Collections.Generic;
using System.Net;
using System.Windows;
using System.Linq;
using System.Collections.ObjectModel;

namespace Redis.SilverlightClient.Messages
{
    public class RedisSubscribeMessage
    {
        private readonly string[] channelNames;

        public RedisSubscribeMessage(string[] channelNames)
        {
            if (channelNames == null)
                throw new ArgumentNullException("channelNames");

            if (channelNames.Length == 0)
                throw new ArgumentException("channelNames");

            this.channelNames = channelNames;
        }

        public string[] ChannelNames { get { return channelNames; } }

        public override string ToString()
        {
            return string.Format("*{0}\r\n$9\r\nSUBSCRIBE\r\n", channelNames.Length + 1)
                + channelNames
                    .Select(channelName =>
                        string.Format("${0}\r\n{1}\r\n", channelName.Length, channelName))
                    .Aggregate((_, __) => _ + __);
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
package io.mewbase.eventsource.impl.kafka;

import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import io.mewbase.bson.BsonCodec;
import io.mewbase.bson.BsonObject;
import io.mewbase.eventsource.EventSink;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Properties;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class KafkaEventSink implements EventSink {

    private final static Logger logger = LoggerFactory.getLogger(KafkaEventSink.class);

    private final KafkaProducer<String, byte[]> kafkaProducer;

    public KafkaEventSink() {
        this( ConfigFactory.load() );
    }

    public KafkaEventSink(Config cfg) {
        final String bootstrapServers = cfg.getString("mewbase.event.sink.kafka.bootstrap");
        final Properties kafkaClientProps = new Properties();
        kafkaClientProps.put("bootstrap.servers", bootstrapServers);
        kafkaClientProps.put("acks", "all");
        kafkaClientProps.put("retries", 0);
        kafkaClientProps.put("batch.size", 16);
        kafkaClientProps.put("linger.ms", 0);   // will still batch for very near (in time records)
        kafkaClientProps.put("buffer.memory", 64 * 1024);
        kafkaProducer = new KafkaProducer<>(kafkaClientProps,
                new org.apache.kafka.common.serialization.StringSerializer(),
                new org.apache.kafka.common.serialization.ByteArraySerializer());
        logger.info("Set up KafkaEventSink " + kafkaProducer);
    }

    @Override
    public Long publishSync(final String channelName, final BsonObject event) {

            CompletableFuture<Long> fut = publishAsync(channelName,event);
            kafkaProducer.flush();
            try {
                return fut.get(5, TimeUnit.SECONDS);
            } catch(Exception exp ) {
                logger.error("Synchronous publish failed to write event " + event, exp);
                return -1l;
            }
    }

    @Override
    public CompletableFuture<Long> publishAsync(final String channelName, final BsonObject event) {
        final CompletableFuture<Long> fut = new CompletableFuture<>();
        kafkaProducer.send(producerRecord(channelName, event),
                (RecordMetadata recordMetadata, Exception exp) -> {
                    if (recordMetadata != null) fut.complete(recordMetadata.offset());
                    if (exp != null) fut.completeExceptionally(exp);
                    // strange possible case if both are null
                    if (!fut.isDone()) fut.completeExceptionally(new IllegalStateException());
                    }
                );
        return fut;
    }

    /**
     * The key will essentially delimit partitioning for our purposes the consumer needs to see all events
     * in order with the correct event number so all event on a topic need to go in the same partition.
     * Assumption if we set the key to the same name as the parition then we can ensure it hashes to the same
     * parition is the broker.
     * BTW we can still replicate the broker for FT purposes.
     * @param channelName
     * @param event
     * @return
     */
    private ProducerRecord<String, byte[]> producerRecord(final String channelName, final BsonObject event) {
        final byte [] eventBytes = BsonCodec.bsonObjectToBsonBytes(event);
        return new ProducerRecord<>(channelName, channelName, eventBytes);
    }

    @Override
    public void close() {
        kafkaProducer.close();
    }

}


text:
package com.bustiblelemons.google.apis.model;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

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

/**
 * Created by bhm on 19.07.14.
 */
@JsonIgnoreProperties(ignoreUnknown = true)
public class GImageResponseData {
    private List<GoogleImageObject> results = new ArrayList<GoogleImageObject>();

    public List<GoogleImageObject> getResults() {
        return results;
    }

    public void setResults(List<GoogleImageObject> results) {
        this.results = results;
    }

}


text:
package com.oculusinfo.binning.io.serialization.impl;

import java.util.List;

import com.oculusinfo.binning.io.serialization.TileSerializer;
import com.oculusinfo.binning.io.serialization.TileSerializerFactory;
import com.oculusinfo.factory.ConfigurableFactory;
import com.oculusinfo.factory.ConfigurationException;
import com.oculusinfo.factory.util.Pair;

/**
 * This serializer factory constructs a
 * {@link com.oculusinfo.binning.io.serialization.impl.PairAvroSerializer},
 * for use with tiles whose values are pairs of primitive Avro types.
 *
 * See {@link com.oculusinfo.binning.io.serialization.impl.PrimitiveAvroSerializer}
 * for information about what primitives are supported, and how.
 */
public class PairAvroSerializerFactory<S, T> extends ConfigurableFactory<TileSerializer<Pair<S, T>>>
{
	private static <S, T> String getName (Class<? extends S> keyType, Class<? extends T> valueType) {
		if (!PrimitiveAvroSerializer.isValidPrimitive(keyType) ||
		    !PrimitiveAvroSerializer.isValidPrimitive(valueType))
			throw new IllegalArgumentException("Attempt to create pair serializer factory with non-primitive class(es) "+keyType+" and/or "+valueType);
		return "("+keyType.getSimpleName().toLowerCase()+", "+valueType.getSimpleName().toLowerCase()+")-a";
	}

	// This is the only way to get a generified class object, but because of erasure, it's guaranteed to work.
	@SuppressWarnings({"rawtypes", "unchecked"})
	private static <S, T> Class<TileSerializer<Pair<S, T>>>
		getGenericSerializerClass (Class<? extends S> keyType, Class<? extends T> valueType) {
		if (!PrimitiveAvroSerializer.isValidPrimitive(keyType) ||
		    !PrimitiveAvroSerializer.isValidPrimitive(valueType))
			throw new IllegalArgumentException("Attempt to create pair array serializer factory with non-primitive class(es) "+keyType+" and/or "+valueType);
		return (Class) TileSerializer.class;
	}

	private Class<? extends S> _keyType;
	private Class<? extends T> _valueType;
	public PairAvroSerializerFactory (ConfigurableFactory<?> parent, List<String> path,
	                                  Class<? extends S> keyType,
	                                  Class<? extends T> valueType) {
		super(getName(keyType, valueType), getGenericSerializerClass(keyType, valueType), parent, path);
		_keyType = keyType;
		_valueType = valueType;
	}

	@Override
	protected TileSerializer<Pair<S, T>> create () throws ConfigurationException {
		return new PairAvroSerializer<S, T>(_keyType, _valueType, TileSerializerFactory.getCodecFactory(this));
	}
}


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="DecoView">
        <attr name="lineWidth" format="dimension" />
        <attr name="rotateAngle" format="integer" />
        <attr name="totalAngle" format="integer" />
        <attr name="arc_gravity_horizontal" format="enum">
            <enum name="Left" value="0"/>
            <enum name="Center" value="1"/>
            <enum name="Right" value="2"/>
            <enum name="Fill" value="3"/>
        </attr>
        <attr name="arc_gravity_vertical" format="enum">
            <enum name="Top" value="0"/>
            <enum name="Center" value="1"/>
            <enum name="Bottom" value="2"/>
            <enum name="Fill" value="3"/>
        </attr>
    </declare-styleable>
</resources>


text:
package com.test;

public class TestIImpl1 implements TestI {
    public void test() {

    }
}


text:
package co.ikust.pomodorotimer.rest.models;

import com.google.gson.annotations.SerializedName;

import java.util.ArrayList;

/**
 * REST Model that holds Trello member data and board list.
 */
public class Member {

    @SerializedName("id")
    private String id;

    @SerializedName("fullName")
    private String fullName;

    @SerializedName("boards")
    private ArrayList<Board> boards;

    public Member(String id, String fullName) {
        this.id = id;
        this.fullName = fullName;
    }

    public String getId() {
        return id;
    }

    public String getFullName() {
        return fullName;
    }

    public ArrayList<Board> getBoards() {
        return boards;
    }
}


text:
<?php

namespace Symfony\Component\DependencyInjection\Tests\Compiler;

use Symfony\Component\DependencyInjection\Compiler\ExtensionCompilerPass;

/**
 * @author Wouter J <wouter@wouterj.nl>
 */
class ExtensionCompilerPassTest extends \PHPUnit_Framework_TestCase
{
    private $container;
    private $pass;

    protected function setUp()
    {
        $this->container = $this->getMock('Symfony\Component\DependencyInjection\ContainerBuilder');
        $this->pass = new ExtensionCompilerPass();
    }

    public function testProcess()
    {
        $extension1 = $this->createExtensionMock(true);
        $extension1->expects($this->once())->method('process');
        $extension2 = $this->createExtensionMock(false);
        $extension3 = $this->createExtensionMock(false);
        $extension4 = $this->createExtensionMock(true);
        $extension4->expects($this->once())->method('process');

        $this->container->expects($this->any())
            ->method('getExtensions')
            ->will($this->returnValue(array($extension1, $extension2, $extension3, $extension4)))
        ;

        $this->pass->process($this->container);
    }

    private function createExtensionMock($hasInlineCompile)
    {
        return $this->getMock('Symfony\Component\DependencyInjection\\'.(
            $hasInlineCompile
            ? 'Compiler\CompilerPassInterface'
            : 'Extension\ExtensionInterface'
        ));
    }
}


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

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Interface org.apache.uima.analysis_engine.ResultSpecification (Apache UIMA Java SDK 2.8.1 User-Level API Documentation)</title>
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Uses of Interface
org.apache.uima.analysis_engine.ResultSpecification

Packages that use ResultSpecification

Package
Description

org.apache.uima

The main package for the Unstructured Information Management Middleware
Architecture.

org.apache.uima.analysis_component

org.apache.uima.analysis_engine

The Analysis Engine interface, along with supporting
interfaces and exception classes.

org.apache.uima.analysis_engine.annotator

The Annotator Interfaces, along with supporting interfaces
and exception classes.

org.apache.uima.flow

org.apache.uima.uimacpp

org.apache.uima.util

Utility classes and interfaces used by UIMA components.

Uses of ResultSpecification in org.apache.uima

Methods in org.apache.uima that return ResultSpecification

Modifier and Type
Method and Description

ResultSpecification
ResourceSpecifierFactory.createResultSpecification()

Creates a ResultSpecification.

Uses of ResultSpecification in org.apache.uima.analysis_component

Methods in org.apache.uima.analysis_component that return ResultSpecification

Modifier and Type
Method and Description

protected ResultSpecification
AnalysisComponent_ImplBase.getResultSpecification()

Gets the ResultSpecification for this AnalysisComponent.

Methods in org.apache.uima.analysis_component with parameters of type ResultSpecification

Modifier and Type
Method and Description

void
AnalysisComponent.setResultSpecification(ResultSpecification aResultSpec)

Sets the ResultSpecification that this AnalysisComponent should use.

void
AnalysisComponent_ImplBase.setResultSpecification(ResultSpecification aResultSpec)

Sets the Result Specification for this Analysis Component.

Uses of ResultSpecification in org.apache.uima.analysis_engine

Methods in org.apache.uima.analysis_engine that return ResultSpecification

Modifier and Type
Method and Description

ResultSpecification
AnalysisEngine.createResultSpecification()

A factory method used to create an instance of ResultSpecification for use with this
 AnalysisEngine.

ResultSpecification
AnalysisEngine.createResultSpecification(TypeSystem aTypeSystem)

A factory method used to create an instance of ResultSpecification for use with this
 AnalysisEngine.

Methods in org.apache.uima.analysis_engine with parameters of type ResultSpecification

Modifier and Type
Method and Description

void
AnalysisEngine.process(AnalysisProcessData aProcessData,
       ResultSpecification aResultSpec)

Deprecated.

This is no longer used by the framework and was never intended for users to call.
             Use {#link #process(CAS)} instead.

ProcessTrace
AnalysisEngine.process(CAS aCAS,
       ResultSpecification aResultSpec)

Invokes this AnalysisEngine's analysis logic.

void
AnalysisEngine.process(CAS aCAS,
       ResultSpecification aResultSpec,
       ProcessTrace aTrace)

Invokes this AnalysisEngine's analysis logic.

ProcessTrace
AnalysisEngine.process(JCas aJCas,
       ResultSpecification aResultSpec)

Similar to AnalysisEngine.process(CAS,ResultSpecification) but uses the Java-object-based
 JCas interface instead of the general CAS interface.

void
AnalysisEngine.process(JCas aJCas,
       ResultSpecification aResultSpec,
       ProcessTrace aTrace)

Similar to AnalysisEngine.process(CAS, ResultSpecification, ProcessTrace) but uses the
 Java-object-based JCas interface instead of the general CAS interface.

void
AnalysisEngine.setResultSpecification(ResultSpecification aResultSpec)

Sets the list of output types and features that the application wants this AnalysisEngine to
 produce.

Uses of ResultSpecification in org.apache.uima.analysis_engine.annotator

Methods in org.apache.uima.analysis_engine.annotator with parameters of type ResultSpecification

Modifier and Type
Method and Description

void
GenericAnnotator.process(CAS aCAS,
       ResultSpecification aResultSpec)

Deprecated.

Invokes this annotator's analysis logic.

void
TextAnnotator.process(CAS aCAS,
       ResultSpecification aResultSpec)

Deprecated.

Invokes this annotator's analysis logic.

void
JTextAnnotator.process(JCas aJCas,
       ResultSpecification aResultSpec)

Deprecated.

Invokes this annotator's analysis logic.

Uses of ResultSpecification in org.apache.uima.flow

Methods in org.apache.uima.flow that return ResultSpecification

Modifier and Type
Method and Description

ResultSpecification
SimpleStepWithResultSpec.getResultSpecification()

Deprecated.

Gets the results specification

Methods in org.apache.uima.flow with parameters of type ResultSpecification

Modifier and Type
Method and Description

void
SimpleStepWithResultSpec.setResultSpecification(ResultSpecification aResultSpec)

Deprecated.

Sets the results specification

Constructors in org.apache.uima.flow with parameters of type ResultSpecification

Constructor and Description

SimpleStepWithResultSpec(String aCasProcessorKey,
                        ResultSpecification aResultSpec)

Deprecated.

Uses of ResultSpecification in org.apache.uima.uimacpp

Methods in org.apache.uima.uimacpp with parameters of type ResultSpecification

Modifier and Type
Method and Description

void
UimacppAnalysisComponent.process(CAS cas,
       ResultSpecification aResultSpec)

void
UimacppEngine.process(ResultSpecification rs,
       CAS aCas,
       boolean casIsEmpty)

process the document.

Uses of ResultSpecification in org.apache.uima.util

Methods in org.apache.uima.util that return ResultSpecification

Modifier and Type
Method and Description

ResultSpecification
XMLParser.parseResultSpecification(XMLInputSource aInput)

Parses a ResultSpecification from an XML input stream.

ResultSpecification
XMLParser.parseResultSpecification(XMLInputSource aInput,
                        XMLParser.ParsingOptions aOptions)

Parses a ResultSpecification from an XML input stream.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Copyright © 2006–2015 The Apache Software Foundation. All rights reserved.


text:
<?xml version="1.0" encoding="utf-8" ?>
<XnaContent>
    <!-- TODO: replace this Asset with your own XML asset data. -->
  <Asset Type="AODGameLibrary.Effects.CPUParticleGroupType">
    <texture>Textures\lightPoint</texture>
    <groupPosition>
      0 0 0
    </groupPosition>
    <parLifetime>0.05</parLifetime>
    <startColor>
      255 255 255 255
    </startColor>
    <endColor>
      255 255 255 0
    </endColor>
    <minInitialSpeed>0.1</minInitialSpeed>
    <maxInitialSpeed>3</maxInitialSpeed>
    <minScale>0.5</minScale>
    <maxScale>1.5</maxScale>
    <scaleRate>0.1</scaleRate>
    <addParticleNum>3</addParticleNum>
    <pointSize>2.4</pointSize>
    <Deathtime>0.075</Deathtime>
    <particleMoveWithGroup>false</particleMoveWithGroup>
    <name>子弹</name>
  </Asset>
</XnaContent>


text:
package jassimp;

import java.util.Set;

/**
 * Enumerates the types of geometric primitives supported by Assimp.

 */
public enum AiPrimitiveType {
    /**
     * A point primitive.
     */
    POINT(0x1),

    /**
     * A line primitive.
     */
    LINE(0x2),

    /**
     * A triangular primitive.
     */
    TRIANGLE(0x4),

    /**
     * A higher-level polygon with more than 3 edges.

     *
     * A triangle is a polygon, but polygon in this context means
     * "all polygons that are not triangles". The "Triangulate"-Step is provided
     * for your convenience, it splits all polygons in triangles (which are much
     * easier to handle).
     */
    POLYGON(0x8);

    /**
     * Utility method for converting from c/c++ based integer enums to java
     * enums.

     *
     * This method is intended to be used from JNI and my change based on
     * implementation needs.
     *
     * @param set the target set to fill
     * @param rawValue an integer based enum value (as defined by assimp)
     */
    static void fromRawValue(Set<AiPrimitiveType> set, int rawValue) {

        for (AiPrimitiveType type : AiPrimitiveType.values()) {
            if ((type.m_rawValue & rawValue) != 0) {
                set.add(type);
            }
        }
    }

    /**
     * Constructor.
     *
     * @param rawValue maps java enum to c/c++ integer enum values
     */
    private AiPrimitiveType(int rawValue) {
        m_rawValue = rawValue;
    }

    /**
     * The mapped c/c++ integer enum value.
     */
    private final int m_rawValue;
}


text:
package kubeletplugin

import (
	"fmt"

	"google.golang.org/grpc"
	"k8s.io/klog/v2"
	registerapi "k8s.io/kubelet/pkg/apis/pluginregistration/v1"
)

type nodeRegistrar struct {
	logger klog.Logger
	registrationServer
	server *grpcServer
}

// startRegistrar returns a running instance.
func startRegistrar(logger klog.Logger, grpcVerbosity int, interceptor grpc.UnaryServerInterceptor, driverName string, endpoint string, pluginRegistrationEndpoint endpoint) (*nodeRegistrar, error) {
	n := &nodeRegistrar{
		logger: logger,
		registrationServer: registrationServer{
			driverName:        driverName,
			endpoint:          endpoint,
			supportedVersions: []string{"1.0.0"}, // TODO: is this correct?
		},
	}
	s, err := startGRPCServer(logger, grpcVerbosity, interceptor, pluginRegistrationEndpoint, func(grpcServer *grpc.Server) {
		registerapi.RegisterRegistrationServer(grpcServer, n)
	})
	if err != nil {
		return nil, fmt.Errorf("start gRPC server: %v", err)
	}
	n.server = s
	return n, nil
}

// stop ensures that the registrar is not running anymore and cleans up all resources.
// It is idempotent and may be called with a nil pointer.
func (s *nodeRegistrar) stop() {
	if s == nil {
		return
	}
	s.server.stop()
}


text:
package servicesTest;

import groupservice.Person;
import es.bsc.compss.types.annotations.Parameter;
import es.bsc.compss.types.annotations.parameter.Direction;
import es.bsc.compss.types.annotations.task.Method;
import es.bsc.compss.types.annotations.task.Service;

public interface ServicesTestItf {

    @Method(declaringClass = "servicesTest.ServicesTestImpl")
    public void print(@Parameter(direction = Direction.IN) Person p);

    @Method(declaringClass = "servicesTest.ServicesTestImpl")
    public Person createPerson();

    @Service(name = "GroupService", namespace = "http://groupService", port = "GroupServicePort")
    public int getNumWorkers();

    @Service(name = "GroupService", namespace = "http://groupService", port = "GroupServicePort")
    public Person getOwner();

    @Service(name = "GroupService", namespace = "http://groupService", port = "GroupServicePort")
    public Person getWorker(@Parameter(direction = Direction.IN) int id);

    @Service(name = "GroupService", namespace = "http://groupService", port = "GroupServicePort")
    public double productivity();

    @Service(name = "GroupService", namespace = "http://groupService", port = "GroupServicePort")
    public void setNumWorkers(@Parameter(direction = Direction.IN) int numWorkers);

    @Service(name = "GroupService", namespace = "http://groupService", port = "GroupServicePort")
    public void setWorker(@Parameter(direction = Direction.IN) Person worker,
        @Parameter(direction = Direction.IN) int id);

}


text:
#import "CPTAnimation.h"

#import "CPTAnimationOperation.h"
#import "CPTAnimationPeriod.h"
#import "_CPTAnimationTimingFunctions.h"

static const CGFloat kCPTAnimationFrameRate = CPTFloat(1.0 / 60.0); // 60 frames per second

static CPTAnimation *instance = nil;

/// @cond
@interface CPTAnimation()

@property (nonatomic, readwrite, assign) CGFloat timeOffset;
@property (nonatomic, readwrite, retain) NSMutableArray *animationOperations;
@property (nonatomic, readwrite, retain) NSMutableArray *runningAnimationOperations;
@property (nonatomic, readwrite, retain) NSMutableArray *expiredAnimationOperations;
@property (nonatomic, readwrite, retain) NSTimer *timer;

+(SEL)setterFromProperty:(NSString *)property;

-(CPTAnimationTimingFunction)timingFunctionForAnimationCurve:(CPTAnimationCurve)animationCurve;
-(void)update:(NSTimer *)theTimer;

@end
/// @endcond

#pragma mark -

/** @brief The controller for Core Plot animations.
 *
 *  Many Core Plot objects are subclasses of CALayer and can take advantage of all of the animation support
 *  provided by Core Animation. However, some objects, e.g., plot spaces, cannot be animated by Core Animation.
 *  It also does not support @ref NSDecimal properties that are common throughout Core Plot.
 *
 *  CPTAnimation provides animation support for all of these things. It can animate any property (of the supported data types)
 *  on objects of any class.
 **/
@implementation CPTAnimation

/** @property CGFloat timeOffset
 *  @brief The animation clock. This value is incremented for each frame while animations are running.
 **/
@synthesize timeOffset;

/** @property CPTAnimationCurve defaultAnimationCurve
 *  @brief The animation curve used when an animation operation specifies the #CPTAnimationCurveDefault animation curve.
 **/
@synthesize defaultAnimationCurve;

/** @internal
 *  @property NSMutableArray *animationOperations
 *
 *  @brief The list of animation operations currently running or waiting to run.
 **/
@synthesize animationOperations;

/** @internal
 *  @property NSMutableArray *runningAnimationOperations
 *  @brief The list of running animation operations.
 **/
@synthesize runningAnimationOperations;

/** @internal
 *  @property NSMutableArray *expiredAnimationOperations
 *  @brief The list of completed animation operations.
 *
 *  These operations are removed from @ref animationOperations and the list is cleared after every animation frame.
 **/
@synthesize expiredAnimationOperations;

/** @internal
 *  @property NSTimer *timer
 *  @brief The animation timer. Each tick of the timer corresponds to one animation frame.
 **/
@synthesize timer;

/// @name Initialization
/// @{

/** @brief Initializes a newly allocated CPTAnimation object.
 *
 *  This is the designated initializer. The initialized object will have the following properties:
 *  - @ref timeOffset = @num{0.0}
 *  - @ref defaultAnimationCurve = #CPTAnimationCurveLinear
 *
 *  @return The initialized object.
 **/
-(id)init
{
    if ( (self = [super init]) ) {
        animationOperations        = [[NSMutableArray alloc] init];
        runningAnimationOperations = [[NSMutableArray alloc] init];
        expiredAnimationOperations = [[NSMutableArray alloc] init];
        timer                      = nil;
        timeOffset                 = 0.0;
        defaultAnimationCurve      = CPTAnimationCurveLinear;
    }

    return self;
}

/// @}

/// @cond

-(void)dealloc
{
    for ( CPTAnimationOperation *animationOperation in animationOperations ) {
        NSObject<CPTAnimationDelegate> *animationDelegate = animationOperation.delegate;

        if ( [animationDelegate respondsToSelector:@selector(animationCancelled:)] ) {
            [animationDelegate performSelector:@selector(animationCancelled:)
                                    withObject:animationOperation
                                    afterDelay:0];
        }
    }

    [animationOperations release];
    [runningAnimationOperations release];
    [expiredAnimationOperations release];

    [timer invalidate];
    [timer release];

    [super dealloc];
}

/// @endcond

#pragma mark -

/** @brief A shared CPTAnimation instance responsible for scheduling and executing animations.
 *  @return The shared CPTAnimation instance.
 **/
+(CPTAnimation *)sharedInstance
{
    if ( !instance ) {
        instance = [[CPTAnimation alloc] init];
    }
    return instance;
}

#pragma mark -

/** @brief Creates an animation operation with the given properties and adds it to the animation queue.
 *  @param object The object to animate.
 *  @param property The name of the property of @par{object} to animate. The property must have both getter and setter methods.
 *  @param period The animation period.
 *  @param animationCurve The animation curve used to animate the new operation.
 *  @param delegate The animation delegate (can be @nil).
 *  @return The queued animation operation.
 **/
+(CPTAnimationOperation *)animate:(id)object property:(NSString *)property period:(CPTAnimationPeriod *)period animationCurve:(CPTAnimationCurve)animationCurve delegate:(NSObject<CPTAnimationDelegate> *)delegate
{
    CPTAnimationOperation *animationOperation = [[CPTAnimationOperation alloc] init];

    animationOperation.period         = period;
    animationOperation.animationCurve = animationCurve;
    animationOperation.delegate       = delegate;

    if ( object ) {
        animationOperation.boundObject = object;
        animationOperation.boundGetter = NSSelectorFromString(property);
        animationOperation.boundSetter = [CPTAnimation setterFromProperty:property];

        if ( ![object respondsToSelector:animationOperation.boundGetter] || ![object respondsToSelector:animationOperation.boundSetter] ) {
            animationOperation.boundObject = nil;
            animationOperation.boundGetter = NULL;
            animationOperation.boundSetter = NULL;
        }
    }

    [[CPTAnimation sharedInstance] performSelector:@selector(addAnimationOperation:) withObject:animationOperation afterDelay:0];

    return [animationOperation autorelease];
}

/// @cond

+(SEL)setterFromProperty:(NSString *)property
{
    return NSSelectorFromString([NSString stringWithFormat:@"set%@:", [property stringByReplacingCharactersInRange:NSMakeRange(0, 1) withString:[[property substringToIndex:1] capitalizedString]]]);
}

/// @endcond

#pragma mark -

/** @brief Adds an animation operation to the animation queue.
 *  @param animationOperation The animation operation to add.
 *  @return The queued animation operation.
 **/
-(CPTAnimationOperation *)addAnimationOperation:(CPTAnimationOperation *)animationOperation
{
    if ( animationOperation ) {
        [self.animationOperations addObject:animationOperation];

        if ( !self.timer ) {
            self.timer = [NSTimer timerWithTimeInterval:kCPTAnimationFrameRate target:self selector:@selector(update:) userInfo:nil repeats:YES];
            [[NSRunLoop mainRunLoop] addTimer:self.timer forMode:NSDefaultRunLoopMode];
        }
    }

    return animationOperation;
}

/** @brief Removes an animation operation from the animation queue.
 *  @param animationOperation The animation operation to remove.
 **/
-(void)removeAnimationOperation:(CPTAnimationOperation *)animationOperation
{
    if ( animationOperation ) {
        NSMutableArray *theAnimationOperations = self.animationOperations;

        if ( [theAnimationOperations containsObject:animationOperation] ) {
            [self.expiredAnimationOperations addObject:animationOperation];
            [theAnimationOperations removeObject:animationOperation];
        }
    }
}

/** @brief Removes all animation operations from the animation queue.
**/
-(void)removeAllAnimationOperations
{
    NSMutableArray *theAnimationOperations = self.animationOperations;

    [self.expiredAnimationOperations addObjectsFromArray:theAnimationOperations];
    [theAnimationOperations removeAllObjects];
}

#pragma mark -

/// @cond

-(void)update:(NSTimer *)theTimer
{
    self.timeOffset += kCPTAnimationFrameRate;

    NSMutableArray *theAnimationOperations = self.animationOperations;
    NSMutableArray *runningOperations      = self.runningAnimationOperations;
    NSMutableArray *expiredOperations      = self.expiredAnimationOperations;

    CGFloat currentTime = self.timeOffset;
    Class valueClass    = [NSValue class];

    for ( CPTAnimationOperation *animationOperation in theAnimationOperations ) {
        NSObject<CPTAnimationDelegate> *animationDelegate = animationOperation.delegate;

        CPTAnimationPeriod *period = animationOperation.period;

        CGFloat duration  = period.duration;
        CGFloat startTime = period.startOffset + period.delay;
        CGFloat endTime   = startTime + duration;

        if ( currentTime > endTime ) {
            [expiredOperations addObject:animationOperation];

            if ( [animationDelegate respondsToSelector:@selector(animationDidFinish:)] ) {
                [animationDelegate performSelector:@selector(animationDidFinish:)
                                        withObject:animationOperation
                                        afterDelay:0];
            }
        }
        else if ( currentTime >= startTime ) {
            id boundObject = animationOperation.boundObject;

            CPTAnimationTimingFunction timingFunction = [self timingFunctionForAnimationCurve:animationOperation.animationCurve];

            if ( boundObject && timingFunction ) {
                if ( ![runningOperations containsObject:animationOperation] ) {
                    [runningOperations addObject:animationOperation];

                    if ( [animationDelegate respondsToSelector:@selector(animationDidStart:)] ) {
                        [animationDelegate performSelector:@selector(animationDidStart:)
                                                withObject:animationOperation
                                                afterDelay:0];
                    }
                }

                CGFloat progress = timingFunction(currentTime - startTime, duration);

                NSValue *tweenedValue = [period tweenedValueForProgress:progress];
                SEL boundSetter       = animationOperation.boundSetter;

                NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[[boundObject class] instanceMethodSignatureForSelector:boundSetter]];
                [invocation setTarget:boundObject];
                [invocation setSelector:boundSetter];

                if ( [tweenedValue isKindOfClass:valueClass] ) {
                    NSUInteger bufferSize = 0;
                    NSGetSizeAndAlignment(tweenedValue.objCType, &bufferSize, NULL);

                    void *buffer = malloc(bufferSize);
                    [tweenedValue getValue:buffer];

                    [invocation setArgument:buffer atIndex:2];

                    free(buffer);
                }
                else {
                    [invocation setArgument:&tweenedValue atIndex:2];
                }

                @try {
                    if ( [animationDelegate respondsToSelector:@selector(animationWillUpdate:)] ) {
                        [animationDelegate performSelector:@selector(animationWillUpdate:)
                                                withObject:animationOperation
                                                afterDelay:0];
                    }

                    [invocation invoke];

                    if ( [animationDelegate respondsToSelector:@selector(animationDidUpdate:)] ) {
                        [animationDelegate performSelector:@selector(animationDidUpdate:)
                                                withObject:animationOperation
                                                afterDelay:0];
                    }
                }
                @catch ( NSException *exception ) {
                    // something went wrong; don't run this operation any more
                    [expiredOperations addObject:animationOperation];

                    if ( [animationDelegate respondsToSelector:@selector(animationCancelled:)] ) {
                        [animationDelegate performSelector:@selector(animationCancelled:)
                                                withObject:animationOperation
                                                afterDelay:0];
                    }
                }
            }
        }
    }

    for ( CPTAnimationOperation *animationOperation in expiredOperations ) {
        [runningOperations removeObjectIdenticalTo:animationOperation];
        [theAnimationOperations removeObjectIdenticalTo:animationOperation];
    }

    [expiredOperations removeAllObjects];

    if ( theAnimationOperations.count == 0 ) {
        [self.timer invalidate];
        self.timer = nil;
    }
}

/// @endcond

#pragma mark -

/// @cond

-(CPTAnimationTimingFunction)timingFunctionForAnimationCurve:(CPTAnimationCurve)animationCurve
{
    CPTAnimationTimingFunction timingFunction;

    if ( animationCurve == CPTAnimationCurveDefault ) {
        animationCurve = self.defaultAnimationCurve;
    }

    switch ( animationCurve ) {
        case CPTAnimationCurveLinear:
            timingFunction = CPTAnimationTimingFunctionLinear;
            break;

        case CPTAnimationCurveBackIn:
            timingFunction = CPTAnimationTimingFunctionBackIn;
            break;

        case CPTAnimationCurveBackOut:
            timingFunction = CPTAnimationTimingFunctionBackOut;
            break;

        case CPTAnimationCurveBackInOut:
            timingFunction = CPTAnimationTimingFunctionBackInOut;
            break;

        case CPTAnimationCurveBounceIn:
            timingFunction = CPTAnimationTimingFunctionBounceIn;
            break;

        case CPTAnimationCurveBounceOut:
            timingFunction = CPTAnimationTimingFunctionBounceOut;
            break;

        case CPTAnimationCurveBounceInOut:
            timingFunction = CPTAnimationTimingFunctionBounceInOut;
            break;

        case CPTAnimationCurveCircularIn:
            timingFunction = CPTAnimationTimingFunctionCircularIn;
            break;

        case CPTAnimationCurveCircularOut:
            timingFunction = CPTAnimationTimingFunctionCircularOut;
            break;

        case CPTAnimationCurveCircularInOut:
            timingFunction = CPTAnimationTimingFunctionCircularInOut;
            break;

        case CPTAnimationCurveElasticIn:
            timingFunction = CPTAnimationTimingFunctionElasticIn;
            break;

        case CPTAnimationCurveElasticOut:
            timingFunction = CPTAnimationTimingFunctionElasticOut;
            break;

        case CPTAnimationCurveElasticInOut:
            timingFunction = CPTAnimationTimingFunctionElasticInOut;
            break;

        case CPTAnimationCurveExponentialIn:
            timingFunction = CPTAnimationTimingFunctionExponentialIn;
            break;

        case CPTAnimationCurveExponentialOut:
            timingFunction = CPTAnimationTimingFunctionExponentialOut;
            break;

        case CPTAnimationCurveExponentialInOut:
            timingFunction = CPTAnimationTimingFunctionExponentialInOut;
            break;

        case CPTAnimationCurveSinusoidalIn:
            timingFunction = CPTAnimationTimingFunctionSinusoidalIn;
            break;

        case CPTAnimationCurveSinusoidalOut:
            timingFunction = CPTAnimationTimingFunctionSinusoidalOut;
            break;

        case CPTAnimationCurveSinusoidalInOut:
            timingFunction = CPTAnimationTimingFunctionSinusoidalInOut;
            break;

        case CPTAnimationCurveCubicIn:
            timingFunction = CPTAnimationTimingFunctionCubicIn;
            break;

        case CPTAnimationCurveCubicOut:
            timingFunction = CPTAnimationTimingFunctionCubicOut;
            break;

        case CPTAnimationCurveCubicInOut:
            timingFunction = CPTAnimationTimingFunctionCubicInOut;
            break;

        case CPTAnimationCurveQuadraticIn:
            timingFunction = CPTAnimationTimingFunctionQuadraticIn;
            break;

        case CPTAnimationCurveQuadraticOut:
            timingFunction = CPTAnimationTimingFunctionQuadraticOut;
            break;

        case CPTAnimationCurveQuadraticInOut:
            timingFunction = CPTAnimationTimingFunctionQuadraticInOut;
            break;

        case CPTAnimationCurveQuarticIn:
            timingFunction = CPTAnimationTimingFunctionQuarticIn;
            break;

        case CPTAnimationCurveQuarticOut:
            timingFunction = CPTAnimationTimingFunctionQuarticOut;
            break;

        case CPTAnimationCurveQuarticInOut:
            timingFunction = CPTAnimationTimingFunctionQuarticInOut;
            break;

        case CPTAnimationCurveQuinticIn:
            timingFunction = CPTAnimationTimingFunctionQuinticIn;
            break;

        case CPTAnimationCurveQuinticOut:
            timingFunction = CPTAnimationTimingFunctionQuinticOut;
            break;

        case CPTAnimationCurveQuinticInOut:
            timingFunction = CPTAnimationTimingFunctionQuinticInOut;
            break;

        default:
            timingFunction = NULL;
    }

    return timingFunction;
}

/// @endcond

#pragma mark -
#pragma mark Description

/// @cond

-(NSString *)description
{
    return [NSString stringWithFormat:@"<%@ timeOffset: %g; %u active and %u expired operations>", [super description], self.timeOffset, (unsigned)self.animationOperations.count, (unsigned)self.expiredAnimationOperations.count];
}

/// @endcond

@end


text:
package com.xeiam.xchange.examples.anx.v2.account;

import java.io.IOException;

import com.xeiam.xchange.Exchange;
import com.xeiam.xchange.dto.account.AccountInfo;
import com.xeiam.xchange.examples.anx.v2.ANXExamplesUtils;
import com.xeiam.xchange.service.polling.account.PollingAccountService;

/**
 * Demo requesting account info at MtGox
 */
public class AccountInfoDemo {

  public static void main(String[] args) throws IOException {

    Exchange anx = ANXExamplesUtils.createExchange();

    // Interested in the private account functionality (authentication)
    PollingAccountService accountService = anx.getPollingAccountService();

    // Get the account information
    AccountInfo accountInfo = accountService.getAccountInfo();

    System.out.println("Wallet as String: " + accountInfo.toString());
  }
}


text:
from django.conf.urls import url

from . import views, views_episode, views_network, views_podcast

urlpatterns = [
    url(r'^services/listens_updated$', views.listens_updated),
    url(r'^services/get_episodes$', views.get_episodes),

    url(r'^podcast/listens$', views_podcast.podcast_listen_history),
    url(r'^podcast/listens/location$', views_podcast.podcast_listener_locations),
    url(r'^podcast/listens/location/options$', views_podcast.podcast_listener_locations_specific_source),
    url(r'^podcast/listens/location/(?P<iso_code>[A-Z0-9]{2})$', views_podcast.podcast_listener_locations_specific),
    url(r'^podcast/listens/episode$', views_podcast.podcast_listen_by_episode),
    url(r'^podcast/listens/breakdown$', views_podcast.podcast_listen_breakdown),
    url(r'^podcast/listens/agent$', views_podcast.podcast_listen_platform_breakdown),
    url(r'^podcast/listens/os$', views_podcast.podcast_listen_os_breakdown),
    url(r'^podcast/listens/top-episodes$', views_podcast.podcast_top_episodes),
    url(r'^podcast/growth$', views_podcast.podcast_growth),
    url(r'^podcast/subscribers$', views_podcast.podcast_subscriber_history),
    url(r'^podcast/subscribers/location$', views_podcast.podcast_subscriber_locations),
    url(r'^podcast/subscribers/location/options$', views_podcast.podcast_subscriber_locations_specific_source),
    url(r'^podcast/subscribers/location/(?P<iso_code>[A-Z0-9]{2})$', views_podcast.podcast_subscriber_locations_specific),

    url(r'^episode/listens$', views_episode.episode_listen_history),
    url(r'^episode/listens/agent$', views_episode.episode_listen_platform_breakdown),
    url(r'^episode/listens/breakdown$', views_episode.episode_listen_breakdown),
    url(r'^episode/listens/location$', views_episode.episode_listener_locations),
    url(r'^episode/listens/location/options$', views_episode.episode_listener_locations_specific_source),
    url(r'^episode/listens/location/(?P<iso_code>[A-Z0-9]{2})$', views_episode.episode_listener_locations_specific),
    url(r'^episode/growth$', views_episode.episode_growth),

    url(r'^network/listens$', views_network.network_listen_history),
    url(r'^network/listens/agent$', views_network.network_listen_platform_breakdown),
    url(r'^network/listens/breakdown$', views_network.network_listen_breakdown),
    url(r'^network/listens/location$', views_network.network_listener_locations),
    url(r'^network/listens/location/options$', views_network.network_listener_locations_specific_source),
    url(r'^network/listens/location/(?P<iso_code>[A-Z0-9]{2})$', views_network.network_listener_locations_specific),
    url(r'^network/growth$', views_network.network_growth),
    url(r'^network/subscribers$', views_network.network_subscriber_history),
    url(r'^network/subscribers/location$', views_network.network_subscriber_locations),
    url(r'^network/subscribers/location/options$', views_network.network_subscriber_locations_specific_source),
    url(r'^network/subscribers/location/(?P<iso_code>[A-Z0-9]{2})$', views_network.network_subscriber_locations_specific),

]


text:
using System;
using NLog;
using PoESkillTree.Engine.GameModel;
using PoESkillTree.Localization;
using PoESkillTree.Model.Builds;

namespace PoESkillTree.ViewModels.Builds
{
    /// <summary>
    /// <see cref="IBuildViewModel"/> that wraps a <see cref="PoEBuild"/> and therefore represents a leaf build.
    /// </summary>
    public class BuildViewModel : AbstractBuildViewModel<PoEBuild>
    {
        private static readonly ILogger Log = LogManager.GetCurrentClassLogger();

        private bool _currentlyOpen;
        private bool _isVisible;
        private CharacterClass _characterClass;
        private string? _ascendancyClass;
        private uint _pointsUsed;

        /// <summary>
        /// Gets or sets whether this is the currently opened build.
        /// </summary>
        public bool CurrentlyOpen
        {
            get => _currentlyOpen;
            set { SetProperty(ref _currentlyOpen, value, () => OnPropertyChanged(nameof(Image))); }
        }

        /// <summary>
        /// Gets whether this build should be visible in the UI.
        /// </summary>
        public bool IsVisible
        {
            get => _isVisible;
            private set => SetProperty(ref _isVisible, value);
        }

        /// <summary>
        /// Gets the character class of the represented tree.
        /// </summary>
        public CharacterClass CharacterClass
        {
            get => _characterClass;
            private set => SetProperty(ref _characterClass, value);
        }

        /// <summary>
        /// Gets the ascendancy class of the represented tree.
        /// </summary>
        public string? AscendancyClass
        {
            get => _ascendancyClass;
            private set => SetProperty(ref _ascendancyClass, value);
        }

        /// <summary>
        /// Gets the number of points the represented tree uses.
        /// </summary>
        private uint PointsUsed
        {
            get => _pointsUsed;
            set => SetProperty(ref _pointsUsed, value);
        }

        private string ClassName => AscendancyClass ?? CharacterClass.ToString();

        /// <summary>
        /// Gets the path to a image describing this build.
        /// </summary>
        public string Image
        {
            get
            {
                var imgPath = "/PoESkillTree;component/Images/" + ClassName;
                if (CurrentlyOpen)
                    imgPath += "_Highlighted";
                return imgPath + ".jpg";
            }
        }

        /// <summary>
        /// Gets a description of this build.
        /// </summary>
        public string Description =>
            string.Format(L10n.Plural("{0}, {1} point used", "{0}, {1} points used", PointsUsed),
                ClassName, PointsUsed);

        /// <param name="poEBuild">The wrapped build.</param>
        /// <param name="filterPredicate">A predicate that returns whether the given <see cref="IBuildViewModel"/>
        /// should be filtered or not.</param>
        public BuildViewModel(PoEBuild poEBuild, Predicate<IBuildViewModel> filterPredicate) : base(poEBuild, filterPredicate)
        {
            IsVisible = FilterPredicate(this);
            poEBuild.PropertyChanged += (sender, args) =>
            {
                switch (args.PropertyName)
                {
                    case nameof(PoEBuild.TreeUrl):
                        UpdateTreeDependingProperties();
                        break;
                }
                ApplyFilter();
            };
            PropertyChanged += (sender, args) =>
            {
                switch (args.PropertyName)
                {
                    case nameof(PointsUsed):
                        OnPropertyChanged(nameof(Description));
                        break;
                    case nameof(CharacterClass):
                        OnPropertyChanged(nameof(Description));
                        OnPropertyChanged(nameof(Image));
                        break;
                    case nameof(AscendancyClass):
                        OnPropertyChanged(nameof(Description));
                        OnPropertyChanged(nameof(Image));
                        break;
                    case nameof(SkillTree):
                        UpdateTreeDependingProperties();
                        break;
                }
                if (args.PropertyName != nameof(IsVisible))
                    ApplyFilter();
            };
        }

        private void UpdateTreeDependingProperties()
        {
            if (SkillTree == null || string.IsNullOrEmpty(Build.TreeUrl))
                return;

            var data = SkillTree.DecodeUrl(Build.TreeUrl);

            if (data.IsValid)
            {
                PointsUsed = (uint)data.SkilledNodesIds.Count;
                CharacterClass = data.CharacterClass;
                AscendancyClass = SkillTree.AscendancyClasses.GetAscendancyClassName(data.CharacterClass, data.AscendancyClassId);
            }
            else
            {
                Log.Warn($"Could not get tree depending properties for {Build.Name} because the tree is invalid: {Build.TreeUrl}");
                PointsUsed = 0;
            }
        }

        public override void ApplyFilter()
        {
            IsVisible = FilterPredicate(this);
        }
    }
}


text:
		<TITLE>Artistic Style - Release Notes</TITLE>
		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
		<meta name="CREATED" content="19981123;1064600">
		<meta name="CHANGEDBY" content="Tal Davidson">
		<meta name="CHANGED" content="19981123;1091900">
		<meta name="GENERATOR" content="Microsoft FrontPage 4.0">

Artistic Style - Release notes

In Artistic Style 1.15.3 (7 March 2002)

Bug fix in handling of brackets after line-comments.

Bug fix: C# add/remove event property headers now properly formatted.

In Artistic Style 1.15.2 (2 March 2002)

Bug fixes in exception handling phrases, e.g. multiple catches and
					try..finally.

In Artistic Style 1.15.1 (2 March 2002)

Bug fix: C# properties are now formatted properly.

In Artistic Style 1.15.0 (2 March 2002)

Added support for C#.

Artistic Style is now licensed only under the GNU Public License (GPL).

Compilation under  G++ 3.0 now works properly.

Bug fix: Opening brackets that appear at the begining of a line immediately
					after an empty line comment are now handled properly, and not appended as part
					of the line comment.

Bug fix: Brackets inside comments are now not misindented within the comment.

In Artistic Style 1.14.1 (2 June 2001)

Bug fix: : '<' and '>' symbols within template declarations (e.g.
					'foo<bar*, xoo>') are now left unpadded in the padding modes.

Bug fix: Fixed false recognizing of  headers within larger words
					(e.g. 'catch' in 'gcatch').

empIn Artistic Style 1.14.0 (1 June 2001)

Bug fix: Fixed indentation of statements within preprocessor '#if...'
					statements.

Bug fix: Templates are now not broken from their bodies.

Bug fix: '<' and '>' symbols within template definitions (e.g.
					'template<class T>') are now left unpadded in the padding modes.

In Artistic Style 1.13.8 (13 April 2001)

Bug fix: Fixed indentation of multiple nested non-block brackets, such as in
					multi bracketed static array declarations.

In Artistic Style 1.13.7 (6 April 2001)

					Newoption:'--force-indent=tab=#' (or 'T#') instructs astyle to indent using
					tabs in all the pre-statement white space, including areas
					astyle's '--indent=tab' prefers to indent using spaces, such as white
					space in multi-line statements.

					Bug fix: Fixed unwanted empty line insertions between empty blocks (e.g.
					'{}') and closing brackets that come immediately after them.

Bug fix: Fixed unwanted empty line insertions immediately after colons (e.g.
					'default:', 'label:', ...)

In Artistic Style 1.13.6 (24 January 2001)

Bug fix: Preprocessor lines now remain unpadded in padding modes.

In Artistic Style 1.13.5 (24 January 2001)

Bug fix: Fixed the insertion of phantom empty lines immediately after {}
					blocks.

Bug fix: Bare open brackets ('{') with no preceding headers are now broken
					appropriately from their preceding code lines in the 'attach'and
					'linux' bracketmodes.

Bug fix: Fixed operator recognition for long operators such as '>>=',
					'<<= '.

In Artistic Style 1.13.4 (24 January 2001)

Bug fix: L" unicode strings are now handled properly in padding modes.

Bug fix: Fixed the padding around '-' operators (which went sour somewhere in
					the past).

Bug fix: Fixed the handling of exponent numbers (e.g. 12.2e+2) in padding
					modes. The fix enables 'e+' to be regarded as part of the exponent.

In Artistic Style 1.13.3 (23 January 2001)

Line that contain both headers and their following non-header
					code (e.g. 'if (isFoo) doBar();') are now broken by default into multiple
					lines. To keep these lines as single lines, use '--one-line= keep-statements'.

Added the new option '--break-elseifs' which breaks 'else if()' statements
					into multiple lines.

The option block breaking options now works properly with the padding
					options.

Various minor bug fixes.

In Artistic Style 1.13.2 (21 January 2001)

Added the new option '--brackets=break-closing-headers'. When this option
					is added to either '--brackets=attach' or '--brackets= linux',
					astyle breaks closing headers (e.g. 'else', 'catch') from their
					preceding closing brackets.

'--break-blocks' and '--break-blocks= all' now correctly handle blocks that
					appear immediately before closing brackets, and do not append empty lines
					between them and the closing brackets.

In Artistic Style 1.13.0 (27 September 1999)

			Moved back to odd-minor-numbered development versions, and even-minor-numbered
			stable versions.

			Added the new option '--break-blocks' which breaks apart unrelated blocks,
			labels, classes, etc.

			Added the new option '--break-blocks=all' which also breaks apart blocks of
			closing headers, such as 'else', 'catch', etc.

			Fixed indentation handling of labels and class-definition identifiers such as
			'public:', 'protected:', ... (thanks to Daryn Adler for his patch)

			Fixed indentation of nested class definitions. (thanks to Daryn Adler for his
			patch)

				Added the new option '--indent-preprocessor' which (surprisingly) tries to
				reindent C/C++ preprocessor macro lines. Astyle should do an pretty nice
				indentation job if the macro code is sane, but don't expect miracales for
				horrid macro definitions...

In Artistic Style 1.11.6 (27 September 1999)

				Improved indentation of lines containing single-line blocks.

In Artistic Style 1.11.5 (25 September 1999)

				Improved the bugfix for a 'const' keyword bug which resulted in wrong
				indentation of methods that are declared const.

In Artistic Style 1.11.4 (18 September 1999)

			Improved handling of single colons (':') in class headers, e.g. class Foo :
			public Bar { ... }

				Improved handling of single colons (':') in method (constructor) headers, e.g.
				Foo::Foo(int a) : Bar(a)

In Artistic Style 1.11.3 (16 September 1999)

				Fixed a serious bug in the formatting of brackets, introduced in 1.11.2.

In Artistic Style 1.11.2 (10 September 1999)

			Fixed an indentation bug in statements that contain the 'const', that resulted
			in wrong indentation of array blocks that where declared const. (Thanks
			Daniel!)

			Fixed an indentation bug that could arise in lines that appear immediately
			after several preprocessor commands. (Thanks Daniel!).

			Fixed a bug that inserted an empty line after closing brackets if a comment
			appeared immediately prior to the closing bracket. (Thanks Ed!)

				Fixed a bug that eliminated empty lines between closing brackets and
				immediately following opening brackets. (Thanks Ed!)

In Artistic Style 1.11.1 (3 September 1999)

				Fixed a bug that inserted an empty line at the begining of source files.

In Artistic Style 1.11.0 (3 September 1999)

			Astyle now filters out linefeeds ('\r') before begining to parse lines. This
			should take care of bizzare formatting that existed when moving source files
			from Windows (which breaks lines with a linefeed AND newline ("\r\n") to unix
			(which breaks lines only with newlines).

			The "struct", "static" and "synchronized" keywords are now finally handled
			correctly in both the contexts of block headers AND simple keywords.

			Better treatment of precompiler lines that end with backslashes, and the lines
			that immediately follow them.

			The '--indent-classes' (or '-C') option now works correctly (again...).

				Series of short command-line options (e.g. "-b -s4 -C") are now parsed
				correctly.

In Artistic Style 1.10.4 (27 July 1999)

				Fixed a MAJOR bug (inserted in 1.10.3) that resulted wrong handling of
				double-colons ('::') in C++.

In Artistic Style 1.10.3 (24 July 1999)

			Fixed a bug (inserted yesterday) that resulted in unwanted line breaks before
			closing-brackets.

			Fixed a bug in the handling of 'static' blocks in java.

			Added the new option '--indent-cases' (or '-K') for indenting 'case XXX:' lines
			so they are flush with their following code lines.

				Added the new option '--fill-empty-lines' (or '-E') which fills empty lines
				with the white-space of their previous line.

In Artistic Style 1.10.2 (23 July 1999)

				Fixed a series of related bugs that resulted in certain cases of lacking line
				breaks after close-brackets, and colons. Thanks Jeroen!

In Artistic Style 1.10.1 (18 July 1999)

				Fixed a bug (introduced in astyle 1.10.0) that can result in missing line
				breaks before closing brackets if they appear immediately after comments.
				Thanks Larry!

In Artistic Style 1.10.0 Release (14 July 1999)

				Improved handling of empty bracket blocks ( e.g.{ } ). Thanks Michael!

In Artistic Style 1.10.0 Prerelease (4 July 1999)

			Fixed a bug in the in-statement indentation algorithm which resulted in
			sub-optimal indentation of multiple-line conditional statements that
			immediately follow headers such as 'if', 'else if', 'while', etc... As a
			result, the current in-statement indentation is finally what it should have
			been long ago - MUCH better then in the last stable versions.

			The "linux" bracket style (in which definition brackets are broken while code
			brackets are attached) has been fixed, and should finally work correctly.

			Artistic Style can now parse both C/C++ and Java files in the same command.
			Unless a specific language mode is specified (e.g. --style=java or --style=c),
			astyle will now automatically set the language mode according to each file's
			suffix (java mode for the '.java' suffix , c mode  otherwise).

			Multiple statements in a single line (e.g. aaa; bbb; fff;) are now broken up by
			default.

				Added the option '--one-line=keep-statements' (or '-o')
			that keeps multiple statements in a single line attached, thus countering the
			default break detailed above.

				Changed the option previously called '--keep-one-line-blocks'
				to '--one-line=keep-blocks', for similarity with the new
			option above.

				Changed the short option name of the option '--errors-to-standard-output'
				from '-o' to '-X'.

				Up to now, Artistic Style always inserted a minimal indent of twice
				the current selected indent size inside multi-line conditional
				headers ('if', 'while' ...), so that it would be clear where the headers end
				and the code after them begins. The current version adds the option '--min-conditional-indent=#'
				(or '-m#') that sets the absolute minimal indent between
				conditional headers and their multiple-line conditional statements. If this
				option is not specified, the default indent remains twice the current
					selected indent size.

				For example, This option should come very handy in code that already has
				brackets after EVERY conditional statement (even if just one line is in that
				bracket...) - in such a case, it would be wise to set --min-conditional-indent=0

			since the brackets already make it clear where the header ends and the code
			begins...

				Added the ability to set the assumed tab size when in '--indent-tab'
				mode by using '--indent-tab=#' or '-t#' and
				replacing the # with the wanted size. If the size is not
				specified, the size of each tab is assumed to be 4 spaces long.

In Artistic Style 1.8.2 (18 March 1999)

			Fixed pointer handling problems in ASBeautifier that led to crashes when
			parsing preprocessor commands.

			Fixed the problem in locating the default options file in the directory pointed
			to by $HOME or %HOMEPATH% when these system variables do not contain an '/' (or
			'\' ...) at their end.

			Fixed inverse insertion of spaces vs. tabs when in -t mode. (Thanks Brian!)

				Got rid of those pesky C4786 warnings when compiling under Visual C++ (Thanks
				John!)

In Artistic Style 1.8.1 (9 March 1999)

				Changed the '--style=k&r' option to '--style= kr' , so that linux/unix
				machines don't misinterpret the '&' as a background processing command.

In Artistic Style 1.8.0 (3 March 1999)

				Added support for predefined styles. Current supported styles are: ansi,
					k&r, linux, gnu, java. these can be set by using
			'--style=THESTYLE' (e.g. '--style=linux').

				Added '--indent-blocks' (or -G) option, which adds indentation to entire
					blocks, including their brackets, in similar fashion to the
			standard gnu style.

				Added option '--brackets=linux' (or '-l') which breaks definition-block
					brackets, but attaches command-block brackets.

			Padding can now be set separately for operators alone('-p' or '--pad=oper'),
			parentheses alone ('--pad=paren) or both ('-P' or '--pad=all').

				Artistic Style looks for a default options file in the following order:

				1. The contents of the ARTISTIC_STYLE_OPTIONS environment
				variable if it exists.

				2. The file called .astylerc in the directory pointed to by the HOME
				environment variable ( i.e. $HOME/.astylerc ).

				3. The file called .astylerc in the directory pointed to by the HOMEPATH
				environment variable ( i.e. %HOMEPATH%\.astylerc ).

			If a default options file is found, the options in this file will be parsed
			BEFORE the command-line options. Options within the default option file may be
			written without the preliminary '-' or '--'. Indentation within #if , #else and
			#endif precompiler commands now works correctly even if the program lines
			between these precompiler commands contain non-pared brackets.

				Improved handling of labels (e.g. 'exit:'). By default, labels are now flushed
				completely to the left. Labels can also be indented to one indent LESS than
				current standard indentation by using the new option '--indent-labels' (or
				'-L') .

			Fixed handling of the 'operator' keyword when it is preceded by a non space
			character (such as '&' or '*').

			Fixed wrong bracket handling after 'throws' statements.

			Fixed wrong indentation of single-line blocks. These where indented 1 indent to
			much.

			Fixed wrong indentation of headers in internal classes (java mode). These where
			indented 1 indent to little.

			The option ' --errors-to-standard-output' now has the one-letter option '-o'.

				Fixed bug which resulted in an unneeded indent in function-declarations in
				which function-variables are declared before the function declaration and are
				preceded by the 'static' keyword. Thanks Scott.

In Artistic Style 1.6.0   (5 January 1999)

			Fixed zero indentation that resulted when a '-suffix' option was set after a
			'--indent=spaces' (or '-s') option..

			Wrong options are now announced.

				Changed default indentation to NOT automatically indent class blocks and switch
				blocks. Instead, the new options '--indent-classes' (or '-C') and
				'--indent-switches' (or '-S') should be used. The option '--indent-switches'
				replaces the old option '--flush-switches'.

In Artistic Style 1.4.1   (4 January 1999)

			Fixed ability to write options without the preceding '--' in the default
			options file.

			Added one-letter options to most options that had only long-options in version
			1.4.0 .

				Added a '-v' or '--version' option that writes the current Artistic Style
				version.

In Artistic Style 1.4.0   (3 January 1999)

				MAJOR NEW CHANGE IN THE FORMAT OF OPTIONS:

				Options are now either short one-letter options starting with
				'-', or long multi-letter options starting with '--'. The
				Short one-letter options MAY BE ATTACHED TOGETHER. Thus, writing '-bps4' is the
				same as writing '-b -p -s4'.

			Many options that have up to now had a 2 letter format now retain only their
			long format. I truly believe that the combination of attached-one-letter
			options PLUS a default option's file containing long-letter-options related to
			style will be much easier to work with than the previous setup.

				Added support for a default options file (pointed to by the
					ARTISTIC_STYLE_OPTIONS environment variable).

			Changed downloading method from the server. From now, there will be specific
			directories containing the latest stable sources, stable binaries, and
			development sources.

			Space padding ('-p' or '--pad') now works correctly (1) around semicolons and
			commas, (2) between headers that require parentheses after them (such as 'if',
			'while'...)and those parentheses, and (3) after parentheses (unless immediately
			followed by a ';' or ',' or '.') .

			From now on, namespace blocks are NOT indented by default. To indent namespace
			blocks use the new '--indent-namespaces' option.

			Added options '--errors-to-standard-output' for redirection of standard-error
			to standard-output from within Artistic Style, and '--suffix=' for specifying a
			suffix other than '.orig' to append to original filenames..

				Corrected indentation of 'default' in switch statements. (Up to now, this only
				worked correctly in java mode...).

In Artistic Style 1.2.0   (19 December 1998)

			Artistic Style 1.2.0 is the first stable result of a new version numbering, in
			which development versions are numbered with an odd minor number (such as
			1.1.x), and stable versions are numbered with an even number (1.2.x). Thus,
			version 1.2.0 accumulates all the additions/changes of the 1.1.x development
			versions of Artistic Style.

			A new '-ol' formatting mode that eliminates breaking of one-line blocks.

			Fixed a SERIOUS bug, which resulted in wrong formatting of brackets ('{', '}')
			that came IMMEDIATELY AFTER definition type brackets, (e.g. brackets that come
			right after 'class', 'interface', 'name-space', etc ...). This bug was
			mistakenly introduced when I set out to correctly space-pad pointer and
			reference signs, somewhere in version 0.9.x .

			Fixed unwanted elimination of final empty lines.

			Fixed broken indentation of virgin opening-brackets that occur immediately
			after a previous closing-bracket.

				Fixed space-padding to not insert a space in front of ':' characters unless
				they are a part of a '? ... : ' statement.

In Artistic Style 1.0.5   (11 December 1998)

			'extern' blocks now handled correctly.

			Fixed handling of ^= in '-p' mode.

				Win32 executables now contain wildcard expansion. *** Look at the README.TXT
				for info on how to include wildcard expansion abilities when compiling Artistic
				Style under Win32. (Thanks for the info on wildcard-expansion enabling, Nat!!!)

In Artistic Style 1.0.4   (2 December 1998)

				Fixed unwanted space-padding around urinary minuses and '-' symbols within
				exponents (e.g. 2.5E-5) when using the '-p' option.

In Artistic Style 1.0.3   (1 December 1998)

			Control characters now remain in the indented file.

			Fixed a bug in which long quoted white-space sequences where mistakenly
			eliminated in the '-p' mode.

			Fixed unwanted line-breaks in '-ab -p' mode, that in some cases occurred
			between '//' and the rest of a line comment.

				Fixed handling of '>>=', '<<= ' in '-p' mode.

In Artistic Style 1.0.2   (27 November 1998)

			Fixed a SERIOUS bug of missing  needed line-breaks in lines immediately
			after line-comments when in '-ab' mode.

			Support for the 'finally' header.

				lines that contain only white-space now become empty lines.

In Artistic Style 1.0.1   (26 November 1998)

			Fixed a SERIOUS bug, which lacked a needed line-break between  closing
			brackets  and the headers that follow them (e.g. '} else') when in '-bb'
			mode. In fixing the bug, I used a variation on a patch sent by Richard
			Bullington - THANKS!

			Fixed a set of  SERIOUS bugs which inserted an empty line into both the
			start and end of the reindented file.

				Improved documentation of formatting options in the file astyle.html .

In Artistic Style 1.0.0   (24 November 1998)

				Indented files now retain the original file name, while the
				original pre-indented file is saved with a ".orig"at its end. Thus, after the
				call "astyle -bb foo.cpp", the newly indented file will be called "foo.cpp",
				while a file called "foo.cpp.orig" will contain the original
			pre-indented file.

				Artistic Style may now be used and /or modified and/or distributed under EITHER
				the "Artistic License", or the GNU General Public License (GPL).

			Methods with headers that end with 'const' are now properly indented.

				Cleaner, more robust, and better documented source code.

In Artistic Style 0.9.2

			Fixed a serious bug which led to a maximal supported source code line size of
			128 characters!!!

			Maximal supported line size is now 1024 characters.

			Fixed a serious bug in the handling of brackets inside '#define' statements.

				Fixed a serious bug in which '#include' files containing slashes (i.e. #include
				<foo_dir/foo> ) where space-padded when using option '-p' on C, C++
				files.

In Artistic Style 0.9.1

			Much improved space-padding around pointers ('*') and references ('&') and
			the 'operator' key-word  in C and C++ source files when using the '-p'
			space padding option.

			Fixed several pointer handling bugs which led to potential core dumps.

				Version 0.9.1 now includes all the abilities I am planning for the final 1.0
				version, and should be looked at as the first pre-release version of Artistic
						Style.

In Artistic Style 0.9.0

				Added a formatting layer
			(ASFormatter.cpp) around the indentation layer (ASBeautifier.cpp).

			As a result, the following formatting capabilities have been added:

					Bracket ('{' and '}') placement in either ANSI C style or Java style.

						Space padding around operators, i.e. (1+2)*3-4 becomes ( 1 + 2 ) * 3 - 4 .

			Fixed the 'tab' elimination bug introduced in ASBeautifier 0.8.2 .

				Fixed a bug which under-indented class headers containing inheritance info.

In ASBeautifier 0.8.2

			Fixed indentation problem in brackets around 'struct', and 'union' blocks.

			Added recognition for '\' characters in the end of lines.

			Improved indentation of post-method-declaration variable initializations.

				Several minor bug fixes.

In ASBeautifier 0.8.1

				Fixed an important bug in pointer arithmetic which resulted both in phantom
				indentation errors, and in core-dumps when trying to indent java files.

In ASBeautifier 0.8.0

			This is the first public release of ASBeautifier. It is a direct port to C++ of
			JSBeautifier 1.1.1, PLUS extensions to for C++ indentation.

			So far, very little beta-testing has been done for the C++ extensions. This
			should change extremely with the open-source release (this was the case with
			JSBeautifier...), so expect ASBeautifier to become bug-free fast!!!

				The C++ source code is not yet written in optimal quality. I rushed a little so
				that I could release this initial release as soon as possible. This will soon
				change.


text:
Android DDDriverStringCommands::<BIG>Length</BIG>

TID
SDC

<short_desc xmlns="">
          Returns the length of a string or variable.
        </short_desc>

Fields: [ ]=Optional with Default Value

sourceString

<short_desc xmlns="">
              sourceString (could come from a ^variable)
            </short_desc>

resultVar

<short_desc xmlns="">
              the resultVar to place the result of the length
              operation into
            </short_desc>

Examples:

<usage xmlns="">
            C, Length, "abc", lengthVar
          </usage>

<short_desc xmlns="">
              variable lengthVar should contain 3 after this is run
            </short_desc>

[How To Read This Reference]


text:
package org.elasticsearch.xpack.sql.cli.command;

import org.elasticsearch.xpack.sql.cli.CliTerminal;

public interface CliCommand {

    /**
     * Handle the command, return true if the command is handled, false otherwise
     */
    boolean handle(CliTerminal terminal, CliSession cliSession, String line);

}


text:
import { clickable, collection, create, property, isHidden } from 'ember-cli-page-object';

const definition = {
  prevIsHidden: isHidden('[data-test-prev]'),
  nextIsHidden: isHidden('[data-test-next]'),
  prevDisabled: property('disabled', '[data-test-prev]'),
  nextDisabled: property('disabled', '[data-test-next]'),
  clickPrev: clickable('[data-test-prev]'),
  clickNext: clickable('[data-test-next]'),
  clickLastPage: clickable('[data-test-page-button]:last'),
  pageLinks: collection('[data-test-page-button]', {
    isDisabled: property('disabled'),
  }),
};

export default definition;
export const component = create(definition);


text:
package bricks.util.logger;

/**
 * @author      Adrian Tilita <adrian@tilita.ro>
 * @version     1.0.0
 * @since       2016-03
 */
public interface StreamHandler {
    /**
     * Stream the message
     * @param message
     */
    public void stream(String message);
}


text:
package prograavanzada2016.anotherworld.mensajes.request;

import prograavanzada2016.anotherworld.mensajes.MessageBase;

public class EnemigoConsultaMessage extends MessageBase{
	public EnemigoConsultaMessage(String message) {
		this.Payload=message;
	}
	@Override
	public void Resolve() throws Exception {
		this.servicio.ejecutar(this);
	}

}


text:
<?php
/**
 * Created by PhpStorm.
 * User: Administrator
 * Date: 2016/6/9
 * Time: 8:59
 */

namespace Blog\event;

final class Event
{
    const FIRST_EVENT = "lazy_pimple.first_event";

    final private function __construct()
    {

    }
}


text:
goog.provide('ol.easing');

/**
 * Start slow and speed up.
 * @param {number} t Input between 0 and 1.
 * @return {number} Output between 0 and 1.
 * @api
 */
ol.easing.easeIn = function(t) {
  return Math.pow(t, 3);
};

/**
 * Start fast and slow down.
 * @param {number} t Input between 0 and 1.
 * @return {number} Output between 0 and 1.
 * @api
 */
ol.easing.easeOut = function(t) {
  return 1 - ol.easing.easeIn(1 - t);
};

/**
 * Start slow, speed up, and then slow down again.
 * @param {number} t Input between 0 and 1.
 * @return {number} Output between 0 and 1.
 * @api
 */
ol.easing.inAndOut = function(t) {
  return 3 * t * t - 2 * t * t * t;
};

/**
 * Maintain a constant speed over time.
 * @param {number} t Input between 0 and 1.
 * @return {number} Output between 0 and 1.
 * @api
 */
ol.easing.linear = function(t) {
  return t;
};

/**
 * Start slow, speed up, and at the very end slow down again.  This has the
 * same general behavior as {@link ol.easing.inAndOut}, but the final slowdown
 * is delayed.
 * @param {number} t Input between 0 and 1.
 * @return {number} Output between 0 and 1.
 * @api
 */
ol.easing.upAndDown = function(t) {
  if (t < 0.5) {
    return ol.easing.inAndOut(2 * t);
  } else {
    return 1 - ol.easing.inAndOut(2 * (t - 0.5));
  }
};


text:
package com.amazonaws.services.appmesh.model.transform;

import javax.annotation.Generated;

import com.amazonaws.SdkClientException;
import com.amazonaws.services.appmesh.model.*;

import com.amazonaws.protocol.*;
import com.amazonaws.annotation.SdkInternalApi;

/**
 * ListenerTimeoutMarshaller
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
@SdkInternalApi
public class ListenerTimeoutMarshaller {

    private static final MarshallingInfo<StructuredPojo> GRPC_BINDING = MarshallingInfo.builder(MarshallingType.STRUCTURED)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("grpc").build();
    private static final MarshallingInfo<StructuredPojo> HTTP_BINDING = MarshallingInfo.builder(MarshallingType.STRUCTURED)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("http").build();
    private static final MarshallingInfo<StructuredPojo> HTTP2_BINDING = MarshallingInfo.builder(MarshallingType.STRUCTURED)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("http2").build();
    private static final MarshallingInfo<StructuredPojo> TCP_BINDING = MarshallingInfo.builder(MarshallingType.STRUCTURED)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("tcp").build();

    private static final ListenerTimeoutMarshaller instance = new ListenerTimeoutMarshaller();

    public static ListenerTimeoutMarshaller getInstance() {
        return instance;
    }

    /**
     * Marshall the given parameter object.
     */
    public void marshall(ListenerTimeout listenerTimeout, ProtocolMarshaller protocolMarshaller) {

        if (listenerTimeout == null) {
            throw new SdkClientException("Invalid argument passed to marshall(...)");
        }

        try {
            protocolMarshaller.marshall(listenerTimeout.getGrpc(), GRPC_BINDING);
            protocolMarshaller.marshall(listenerTimeout.getHttp(), HTTP_BINDING);
            protocolMarshaller.marshall(listenerTimeout.getHttp2(), HTTP2_BINDING);
            protocolMarshaller.marshall(listenerTimeout.getTcp(), TCP_BINDING);
        } catch (Exception e) {
            throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
        }
    }

}


text:
**Namespace:** [OfficeDevPnP.Core.Entities](OfficeDevPnP.Core.Entities.md)
**Assembly:** OfficeDevPnP.Core.dll
## Syntax
```C#
public YammerUserHomeTab()
```
## See also
- [YammerUserHomeTab](OfficeDevPnP.Core.Entities.YammerUserHomeTab.md)
- [OfficeDevPnP.Core.Entities](OfficeDevPnP.Core.Entities.md)


text:
<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Copyright (c) 2012, SmiteWorks USA LLC -->
<root version="3.0" ccversion="3.0.5.A">
  <character>
    <actionpoints type="number">1</actionpoints>
    <attacks>
      <base>
        <total type="number">0</total>
      </base>
      <melee>
        <misc type="number">0</misc>
        <temporary type="number">0</temporary>
        <total type="number">0</total>
      </melee>
      <ranged>
        <misc type="number">0</misc>
        <temporary type="number">0</temporary>
        <total type="number">0</total>
      </ranged>
    </attacks>
    <meleemodifier type="number"/>
    <powerfocus>
      <implement>
        <order type="number">0</order>
      </implement>
      <weapon>
        <order type="number">0</order>
      </weapon>
    </powerfocus>
    <powermode type="string">standard</powermode>
    <preparationmode type="number">0</preparationmode>
    <rangedmodifier type="number"/>
    <passiveinsight type="number"/>
    <passiveperception type="number"/>
    <age type="string"/>
    <alignment type="string"/>
    <weight type="string"/>
    <appearance type="string"/>
    <class>
      <base type="string"/>
      <paragon type="string"/>
      <epic type="string"/>
    </class>
    <deity/>
    <encumbrance>
      <armorcheckpenalty type="number"/>
      <heavyarmor type="number"/>
      <load       type="number"/>
      <normalload type="number"/>
      <heavyload  type="number"/>
      <dragload   type="number"/>
    </encumbrance>
    <exp type="number"/>
    <expneeded type="number"/>
    <gender type="string"/>
    <height type="string"/>
    <hp>
      <total type="number"/>
      <surgemodifier type="number"/>
      <bloodied type="number"/>
      <surgesmax type="number"/>
      <surge type="number"/>
      <surgesused type="number">0</surgesused>
      <temporary type="number">0</temporary>
      <wounds type="number">0</wounds>
      <faileddeathsaves type="number">0</faileddeathsaves>
      <maxdeathsaves type="number"/>
      <secondwind type="number"/>
    </hp>
    <initiative>
      <misc type="number"/>
      <total type="number"/>
      <temporary type="number"/>
    </initiative>
    <level type="number"/>
    <levelbonus type="number"/>
    <senses type="string"/>
    <name type="string"/>
    <notes type="string"/>
    <proficiencyarmor/>
    <race type="string"/>
    <size type="string"/>
    <speed>
      <base type="number"/>
      <armor type="number"/>
      <misc type="number"/>
      <temporary type="number">0</temporary>
      <final type="number"/>
    </speed>
    <abilities/>
    <coins/>
    <defenses>
      <save>
        <base type="number">0</base>
        <misc type="number">0</misc>
        <temporary type="number">0</temporary>
        <total type="number">0</total>
      </save>
      <special type="string"/>
    </defenses>
    <skilllist/>
    <powers />
    <proficiencyweapon/>
    <specialabilitylist/>
    <weaponlist/>
    <featlist/>
    <languagelist/>
    <inventorylist/>
  </character>
</root>


text:
package org.wso2.carbon.identity.recovery.signup;

import org.apache.commons.lang.StringUtils;
import org.junit.Assert;
import org.mockito.Matchers;
import org.mockito.Mock;

import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.when;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.testng.PowerMockTestCase;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import org.wso2.carbon.consent.mgt.core.ConsentManager;
import org.wso2.carbon.consent.mgt.core.ConsentManagerImpl;
import org.wso2.carbon.consent.mgt.core.exception.ConsentManagementException;
import org.wso2.carbon.consent.mgt.core.model.AddReceiptResponse;
import org.wso2.carbon.consent.mgt.core.model.ConsentManagerConfigurationHolder;
import org.wso2.carbon.consent.mgt.core.model.ReceiptInput;
import org.wso2.carbon.identity.application.common.model.IdentityProvider;
import org.wso2.carbon.identity.application.common.model.User;
import org.wso2.carbon.identity.core.util.IdentityTenantUtil;
import org.wso2.carbon.identity.core.util.IdentityUtil;
import org.wso2.carbon.identity.event.IdentityEventException;
import org.wso2.carbon.identity.event.event.Event;
import org.wso2.carbon.identity.event.services.IdentityEventService;
import org.wso2.carbon.identity.governance.service.notification.NotificationChannels;
import org.wso2.carbon.identity.recovery.IdentityRecoveryConstants;
import org.wso2.carbon.identity.recovery.IdentityRecoveryException;
import org.wso2.carbon.identity.recovery.RecoveryScenarios;
import org.wso2.carbon.identity.recovery.RecoverySteps;
import org.wso2.carbon.identity.recovery.bean.NotificationResponseBean;
import org.wso2.carbon.identity.recovery.internal.IdentityRecoveryServiceDataHolder;
import org.wso2.carbon.identity.recovery.model.UserRecoveryData;
import org.wso2.carbon.identity.recovery.store.JDBCRecoveryDataStore;
import org.wso2.carbon.identity.recovery.store.UserRecoveryDataStore;
import org.wso2.carbon.identity.recovery.util.Utils;
import org.wso2.carbon.idp.mgt.IdentityProviderManager;

import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.testng.Assert.assertEquals;

@PrepareForTest({IdentityUtil.class, Utils.class, IdentityTenantUtil.class, IdentityProviderManager.class,
        Utils.class, JDBCRecoveryDataStore.class})
public class UserSelfRegistrationManagerTest extends PowerMockTestCase {

    private UserSelfRegistrationManager userSelfRegistrationManager = UserSelfRegistrationManager.getInstance();
    private ReceiptInput resultReceipt;
    private String TEST_TENANT_DOMAIN_NAME = "carbon.super";
    private String TEST_USERSTORE_DOMAIN = "PRIMARY";

    @Mock
    IdentityProviderManager identityProviderManager;

    @Mock
    UserRecoveryDataStore userRecoveryDataStore;

    @Mock
    IdentityEventService identityEventService;

    @BeforeTest
    void setup() {

        this.resultReceipt = null;
    }

    String consentData =
            "{\"jurisdiction\":\"someJurisdiction\",\"collectionMethod\":\"Web Form - Self Registration\"," +
                    "\"language\":\"en\",\"piiPrincipalId\":\"DOMAIN/testuser\",\"services\":" +
                    "[{\"tenantDomain\":\"wso2.com\",\"serviceDisplayName\":\"Resident IDP\"," +
                    "\"serviceDescription\":\"Resident IDP\",\"purposes\":[{\"purposeId\":3,\"purposeCategoryId\":[1]," +
                    "\"consentType\":\"EXPLICIT\",\"piiCategory\":[{\"piiCategoryId\":1," +
                    "\"validity\":\"DATE_UNTIL:INDEFINITE\"}],\"primaryPurpose\":true," +
                    "\"termination\":\"DATE_UNTIL:INDEFINITE\",\"thirdPartyDisclosure\":false}],\"tenantId\":1}]," +
                    "\"policyURL\":\"somePolicyUrl\",\"tenantId\":1,\"properties\":{}}";

    /**
     * Testing ResendConfirmationCode for user self registration.
     *
     * @param username                             Username
     * @param userstore                            Userstore domain
     * @param tenantDomain                         Tenant domain
     * @param preferredChannel                     Preferred Notification channel
     * @param errorMsg                             Error scenario
     * @param enableInternalNotificationManagement Manage notifications internally
     * @param expectedChannel                      Expected notification channel
     * @throws Exception If an error occurred while testing.
     */
    @Test(dataProvider = "userDetailsForResendingAccountConfirmation")
    public void testResendConfirmationCode(String username, String userstore, String tenantDomain,
                                           String preferredChannel, String errorMsg,
                                           String enableInternalNotificationManagement, String expectedChannel)
            throws Exception {

        // Build recovery user.
        User user = new User();
        user.setUserName(username);
        user.setUserStoreDomain(userstore);
        user.setTenantDomain(tenantDomain);

        UserRecoveryData userRecoveryData = new UserRecoveryData(user, "1234-4567-890", RecoveryScenarios
                .SELF_SIGN_UP, RecoverySteps.CONFIRM_SIGN_UP);
        // Storing preferred notification channel in remaining set ids.
        userRecoveryData.setRemainingSetIds(preferredChannel);

        mockConfigurations("true", enableInternalNotificationManagement);
        mockJDBCRecoveryDataStore(userRecoveryData);
        mockEmailTrigger();

        NotificationResponseBean responseBean =
                userSelfRegistrationManager.resendConfirmationCode(user, null);
        assertEquals(responseBean.getNotificationChannel(), expectedChannel, errorMsg);
    }

    /**
     * Contains user data related resending self registration notification.
     *
     * @return Object[][]
     */
    @DataProvider(name = "userDetailsForResendingAccountConfirmation")
    private Object[][] userDetailsForResendingAccountConfirmation() {

        String username = "sominda";
        // Notification channel types.
        String EMAIL = NotificationChannels.EMAIL_CHANNEL.getChannelType();
        String SMS = NotificationChannels.SMS_CHANNEL.getChannelType();
        String EXTERNAL = NotificationChannels.EXTERNAL_CHANNEL.getChannelType();

        /* ArrayOrder: Username, Userstore, Tenant domain, Preferred channel, Error message, Manage notifications
        internally, excepted channel */
        return new Object[][]{
                {username, TEST_USERSTORE_DOMAIN, TEST_TENANT_DOMAIN_NAME, EMAIL, "User with EMAIL as Preferred " +
                        "Notification Channel : ", "TRUE", EMAIL},
                {username, TEST_USERSTORE_DOMAIN, TEST_TENANT_DOMAIN_NAME, EMAIL, "User with EMAIL as Preferred " +
                        "Notification Channel but notifications are externally managed : ", "FALSE", EXTERNAL},
                {username, TEST_USERSTORE_DOMAIN, TEST_TENANT_DOMAIN_NAME, SMS, "User with SMS as Preferred " +
                        "Notification Channel : ", "TRUE", SMS},
                {username, TEST_USERSTORE_DOMAIN, TEST_TENANT_DOMAIN_NAME, StringUtils.EMPTY,
                        "User no preferred channel specified : ", "TRUE", null}
        };
    }

    /**
     * Mock user self registration configurations for resend account confirmation.
     *
     * @param enableSelfSignUp            Enable user self registration
     * @param enableInternalNotifications Enable notifications internal management.
     * @throws Exception If an error occurred while mocking configurations.
     */
    private void mockConfigurations(String enableSelfSignUp, String enableInternalNotifications) throws Exception {

        mockStatic(Utils.class);
        when(Utils.getSignUpConfigs(IdentityRecoveryConstants.ConnectorConfig.ENABLE_SELF_SIGNUP,
                TEST_TENANT_DOMAIN_NAME)).thenReturn(enableSelfSignUp);
        when(Utils.getSignUpConfigs(IdentityRecoveryConstants.ConnectorConfig.SIGN_UP_NOTIFICATION_INTERNALLY_MANAGE,
                TEST_TENANT_DOMAIN_NAME)).thenReturn(enableInternalNotifications);
        mockStatic(IdentityUtil.class);
        when(IdentityUtil.getPrimaryDomainName()).thenReturn(TEST_USERSTORE_DOMAIN);
    }

    /**
     * Mock JDBCRecoveryDataStore to store user recovery data.
     *
     * @param userRecoveryData User recovery data to be mocked.
     * @throws IdentityRecoveryException If an error occurred while mocking JDBCRecoveryDataStore.
     */
    private void mockJDBCRecoveryDataStore(UserRecoveryData userRecoveryData) throws IdentityRecoveryException {

        mockStatic(JDBCRecoveryDataStore.class);
        when(JDBCRecoveryDataStore.getInstance()).thenReturn(userRecoveryDataStore);
        when(userRecoveryDataStore.loadWithoutCodeExpiryValidation(Matchers.anyObject())).thenReturn(userRecoveryData);
        doNothing().when(userRecoveryDataStore).invalidate(Matchers.anyString());
        doNothing().when(userRecoveryDataStore).store(Matchers.any(UserRecoveryData.class));
    }

    /**
     * Mock email triggering.
     *
     * @throws IdentityEventException If an error occurred while mocking identityEventService.
     */
    private void mockEmailTrigger() throws IdentityEventException {

        IdentityRecoveryServiceDataHolder.getInstance().setIdentityEventService(identityEventService);
        doNothing().when(identityEventService).handleEvent(Matchers.any(Event.class));
    }

    @Test
    public void testAddConsent() throws Exception {

        PowerMockito.mockStatic(IdentityProviderManager.class);
        IdentityProvider identityProvider = new IdentityProvider();
        PowerMockito.when(identityProviderManager.getInstance()).thenReturn(identityProviderManager);
        PowerMockito.when(identityProviderManager.getResidentIdP(Matchers.anyString())).thenReturn(identityProvider);
        ConsentManager consentManager = new MyConsentManager(new ConsentManagerConfigurationHolder());
        IdentityRecoveryServiceDataHolder.getInstance().setConsentManager(consentManager);
        userSelfRegistrationManager.addUserConsent(consentData, "wso2.com");
        Assert.assertEquals(IdentityRecoveryConstants.Consent.COLLECTION_METHOD_SELF_REGISTRATION,
                resultReceipt.getCollectionMethod());
        Assert.assertEquals("someJurisdiction", resultReceipt.getJurisdiction());
        Assert.assertEquals("en", resultReceipt.getLanguage());
        Assert.assertNotNull(resultReceipt.getServices());
        Assert.assertEquals(1, resultReceipt.getServices().size());
        Assert.assertNotNull(resultReceipt.getServices().get(0).getPurposes());
        Assert.assertEquals(1, resultReceipt.getServices().get(0).getPurposes().size());
        Assert.assertEquals(new Integer(3), resultReceipt.getServices().get(0).getPurposes().get(0).getPurposeId());
        Assert.assertEquals(IdentityRecoveryConstants.Consent.EXPLICIT_CONSENT_TYPE,
                resultReceipt.getServices().get(0).getPurposes().get(0).getConsentType());
        Assert.assertEquals(IdentityRecoveryConstants.Consent.INFINITE_TERMINATION,
                resultReceipt.getServices().get(0).getPurposes().get(0).getTermination());
        Assert.assertEquals(new Integer(3),
                resultReceipt.getServices().get(0).getPurposes().get(0).getPurposeId());
    }

    /**
     * Sample consent manager class.
     */
    class MyConsentManager extends ConsentManagerImpl {

        public MyConsentManager(ConsentManagerConfigurationHolder configHolder) {

            super(configHolder);
        }

        public AddReceiptResponse addConsent(ReceiptInput receiptInput) throws ConsentManagementException {

            resultReceipt = receiptInput;
            return null;
        }
    }
}