text:
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008. All Rights Reserved.                             */
/* Open Source Software - may be modified and shared by FRC teams. The code   */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project.                                                               */
/*----------------------------------------------------------------------------*/

package edu.wpi.first.wpilibj;

import edu.wpi.first.testing.TestClass;

/**
 * @file FakeEncoderTest.java
 * Test the fake encoder classes to verify they are valid for future test use
 * @author Ryan O'Meara
 */
public class FakeQuadEncoderTest extends TestClass implements TestHarness
{

    private final int MAXCOUNT = 500;
    private Counter counter;
    private Counter counter2;
    private FakeQuadEncoder fakeQEncoder;

    public String getName()
    {
        return "FakeQuadEncoder Test";
    }

    public void setup()
    {
        counter = new Counter(CROSSCONNECTAP1);
        counter2 = new Counter(CROSSCONNECTBP1);
        fakeQEncoder = new FakeQuadEncoder(CROSSCONNECTAP2, CROSSCONNECTBP2);
    }

    public void teardown()
    {
        counter.free();
        counter2.free();
        fakeQEncoder.free();
    }

    {
        new Test("Forward counting")
        {

            public void run()
            {
                counter.reset();
                counter2.reset();

                fakeQEncoder.setCount(MAXCOUNT);
                fakeQEncoder.setRate(1);
                counter.start();
                counter2.start();
                fakeQEncoder.execute();
                assertEquals(counter.get(), MAXCOUNT);
                assertEquals(counter2.get(), MAXCOUNT);
            }
        };

        new Test("Reverse counting")
        {

            public void run()
            {
                counter.reset();
                counter2.reset();
                fakeQEncoder.setForward(false);
                fakeQEncoder.setCount(MAXCOUNT);
                fakeQEncoder.setRate(1);
                counter.start();
                counter2.start();
                fakeQEncoder.execute();

                assertEquals(counter.get(), MAXCOUNT);
                assertEquals(counter2.get(), MAXCOUNT);

                counter.stop();
                counter2.stop();
            }
        };
    }
}


text:
function bindingSelect(optional){
	var option = {
			masterSelect:null,
			childSelect:null,
			childDefalueVal:"请选择",
			childVal:null,
			url:"",
			type:"POST",
			dataType:"json",
			beforeFn:null,
			afterFn:null,
			valName:"id",
			htmlName:"name",
	};
	option = $.extend({}, option, optional);
	$(option.masterSelect).data("bSelect",this);

	var _This = this;

	this.initChildValue = function(){
		var childSelect = $(option.childSelect);
		childSelect.empty();
		childSelect.append('<option value="">'+option.childDefalueVal+'</option>');
		var bSelect = childSelect.data("bSelect");
		if(bSelect){
			bSelect.initChildValue();
		}
	}

	$(option.masterSelect).change(function(){
		_This.initChildValue();
		var val = $(this).val();
		if(!val) return;
		var data = {
				id:val
		};
		if ($.isFunction(option.beforeFn)) {
			data = option.beforeFn(data) || data;
		}
		$.ajax({
			type : option.type,
			url : option.url,
			data : data,
			dataType : option.dataType,
			success : function(returnData) {
				if ($.isFunction(option.afterFn)) {
					returnData = option.afterFn(returnData) || returnData;
				}
				var childSelect = $(option.childSelect);
				for (var i = 0; i < returnData.length; i++) {
					var d = returnData[i];
					var valName = d[option.valName];
					var htmlName = d[option.htmlName];
					var selected = "";
					if(option.childVal){
						if(valName == option.childVal){
							selected = "selected";
						}
					}
					childSelect.append('<option value="'+valName+'" '+selected+'>'+htmlName+'</option>');
				}
				childSelect.change();
			}
		});
	});
}

redpajama_set_name: RedPajamaGithub


text:
#include <pcl/visualization/window.h>
#include <vtkCallbackCommand.h>
#include <vtkObject.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <pcl/visualization/keyboard_event.h>
#include <pcl/visualization/mouse_event.h>
#include <pcl/common/time.h>

/////////////////////////////////////////////////////////////////////////////////////////////
pcl::visualization::Window::Window (const std::string& window_name)
  : mouse_command_ (vtkCallbackCommand::New ()),
    keyboard_command_ (vtkCallbackCommand::New ()),
    style_ (vtkSmartPointer<pcl::visualization::PCLVisualizerInteractorStyle>::New ()),
    rens_ (vtkSmartPointer<vtkRendererCollection>::New ())
{
  mouse_command_->SetClientData (this);
  mouse_command_->SetCallback (Window::MouseCallback);

  keyboard_command_->SetClientData (this);
  keyboard_command_->SetCallback (Window::KeyboardCallback);

  // Create a RendererWindow
  win_ = vtkSmartPointer<vtkRenderWindow>::New ();
  win_->SetWindowName (window_name.c_str ());
  win_->AlphaBitPlanesOff ();
  win_->PointSmoothingOff ();
  win_->LineSmoothingOff ();
  win_->PolygonSmoothingOff ();
  win_->SwapBuffersOn ();
  win_->SetStereoTypeToAnaglyph ();

  // Get screen size
  int *scr_size = win_->GetScreenSize ();
  // Set the window size as 1/2 of the screen size
  win_->SetSize (scr_size[0] / 2, scr_size[1] / 2);

  // Create the interactor style
  style_->Initialize ();
  style_->setRendererCollection (rens_);
  style_->UseTimersOn ();

  // Create the interactor
  interactor_ = vtkSmartPointer<vtkRenderWindowInteractor>::New ();
  //interactor_ = vtkSmartPointer<PCLVisualizerInteractor>::New ();

  interactor_->SetRenderWindow (win_);
  interactor_->SetInteractorStyle (style_);
  interactor_->SetDesiredUpdateRate (30.0);
  // Initialize and create timer
  interactor_->Initialize ();
  //interactor_->CreateRepeatingTimer (5000L);
  timer_id_ = interactor_->CreateRepeatingTimer (5000L);
//  interactor_->timer_id_ = interactor_->CreateRepeatingTimer (5000L);
  //interactor_->timer_id_ = interactor_->CreateRepeatingTimer (30L);

  exit_main_loop_timer_callback_ = vtkSmartPointer<ExitMainLoopTimerCallback>::New ();
  exit_main_loop_timer_callback_->window = this;
  exit_main_loop_timer_callback_->right_timer_id = -1;
  interactor_->AddObserver (vtkCommand::TimerEvent, exit_main_loop_timer_callback_);

  exit_callback_ = vtkSmartPointer<ExitCallback>::New ();
  exit_callback_->window = this;
  interactor_->AddObserver (vtkCommand::ExitEvent, exit_callback_);

  resetStoppedFlag ();
}

/////////////////////////////////////////////////////////////////////////////////////////////
pcl::visualization::Window::~Window ()
{
  interactor_->DestroyTimer (timer_id_);
//  interactor_->DestroyTimer (interactor_->timer_id_);
}

/////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::Window::spin ()
{
  resetStoppedFlag ();
  // Render the window before we start the interactor
  win_->Render ();
  interactor_->Start ();
}

/////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::Window::spinOnce (int time, bool force_redraw)
{
  resetStoppedFlag ();

  if (time <= 0)
    time = 1;

  if (force_redraw)
  {
    interactor_->Render ();
    exit_main_loop_timer_callback_->right_timer_id = interactor_->CreateRepeatingTimer (time);
    interactor_->Start ();
    interactor_->DestroyTimer (exit_main_loop_timer_callback_->right_timer_id);
    return;
  }

  DO_EVERY(1.0/interactor_->GetDesiredUpdateRate (),
    interactor_->Render ();
    exit_main_loop_timer_callback_->right_timer_id = interactor_->CreateRepeatingTimer (time);
    interactor_->Start ();
    interactor_->DestroyTimer (exit_main_loop_timer_callback_->right_timer_id);
  );
}

/////////////////////////////////////////////////////////////////////////////////////////////
boost::signals2::connection
pcl::visualization::Window::registerMouseCallback (boost::function<void (const pcl::visualization::MouseEvent&)> callback)
{
  // just add observer at first time when a callback is registered
  if (mouse_signal_.empty())
  {
    interactor_->AddObserver(vtkCommand::MouseMoveEvent, mouse_command_);
    interactor_->AddObserver(vtkCommand::MiddleButtonPressEvent, mouse_command_);
    interactor_->AddObserver(vtkCommand::MiddleButtonReleaseEvent, mouse_command_);
    interactor_->AddObserver(vtkCommand::MouseWheelBackwardEvent, mouse_command_);
    interactor_->AddObserver(vtkCommand::MouseWheelForwardEvent, mouse_command_);
    interactor_->AddObserver(vtkCommand::LeftButtonPressEvent, mouse_command_);
    interactor_->AddObserver(vtkCommand::LeftButtonReleaseEvent, mouse_command_);
    interactor_->AddObserver(vtkCommand::RightButtonPressEvent, mouse_command_);
    interactor_->AddObserver(vtkCommand::RightButtonReleaseEvent, mouse_command_);
  }
  return mouse_signal_.connect(callback);
}

/////////////////////////////////////////////////////////////////////////////////////////////
boost::signals2::connection
pcl::visualization::Window::registerKeyboardCallback (boost::function<void (const pcl::visualization::KeyboardEvent&)> callback)
{
  // just add observer at first time when a callback is registered
  if (keyboard_signal_.empty())
  {
    interactor_->AddObserver(vtkCommand::KeyPressEvent, keyboard_command_);
    interactor_->AddObserver(vtkCommand::KeyReleaseEvent, keyboard_command_);
  }

  return keyboard_signal_.connect(callback);
}

/////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::Window::emitMouseEvent (unsigned long event_id)
{
  int x,y;
  interactor_->GetMousePosition (&x, &y);
  MouseEvent event (MouseEvent::MouseMove, MouseEvent::NoButton, x, y, interactor_->GetAltKey (), interactor_->GetControlKey (), interactor_->GetShiftKey ());
  bool repeat = false;
  switch (event_id)
  {
    case vtkCommand::MouseMoveEvent :
      event.setType(MouseEvent::MouseMove);
      break;

    case vtkCommand::LeftButtonPressEvent :
      event.setButton(MouseEvent::LeftButton);
      if (interactor_->GetRepeatCount () == 0)
        event.setType(MouseEvent::MouseButtonPress);
      else
        event.setType(MouseEvent::MouseDblClick);
      break;

    case vtkCommand::LeftButtonReleaseEvent :
      event.setButton(MouseEvent::LeftButton);
      event.setType(MouseEvent::MouseButtonRelease);
      break;

    case vtkCommand::RightButtonPressEvent :
      event.setButton(MouseEvent::RightButton);
      if (interactor_->GetRepeatCount () == 0)
        event.setType(MouseEvent::MouseButtonPress);
      else
        event.setType(MouseEvent::MouseDblClick);
      break;

    case vtkCommand::RightButtonReleaseEvent :
      event.setButton(MouseEvent::RightButton);
      event.setType(MouseEvent::MouseButtonRelease);
      break;

    case vtkCommand::MiddleButtonPressEvent :
      event.setButton(MouseEvent::MiddleButton);
      if (interactor_->GetRepeatCount () == 0)
        event.setType(MouseEvent::MouseButtonPress);
      else
        event.setType(MouseEvent::MouseDblClick);
      break;

    case vtkCommand::MiddleButtonReleaseEvent :
      event.setButton(MouseEvent::MiddleButton);
      event.setType(MouseEvent::MouseButtonRelease);
      break;

      case vtkCommand::MouseWheelBackwardEvent :
      event.setButton(MouseEvent::VScroll);
      event.setType(MouseEvent::MouseScrollDown);
      if (interactor_->GetRepeatCount () != 0)
        repeat = true;
      break;

    case vtkCommand::MouseWheelForwardEvent :
      event.setButton(MouseEvent::VScroll);
      event.setType(MouseEvent::MouseScrollUp);
      if (interactor_->GetRepeatCount () != 0)
        repeat = true;
      break;
    default:
      return;
  }

  mouse_signal_ (event);
  if (repeat)
    mouse_signal_ (event);
}

/////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::Window::emitKeyboardEvent (unsigned long event_id)
{
  KeyboardEvent event (bool(event_id == vtkCommand::KeyPressEvent), interactor_->GetKeySym (), interactor_->GetKeyCode (), interactor_->GetAltKey (), interactor_->GetControlKey (), interactor_->GetShiftKey ());
  keyboard_signal_ (event);
}

/////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::Window::MouseCallback(vtkObject*, unsigned long eid, void* clientdata, void* calldata)
{
  Window* window = reinterpret_cast<Window*> (clientdata);
  window->emitMouseEvent (eid);
}

/////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::Window::KeyboardCallback(vtkObject*, unsigned long eid, void* clientdata, void* calldata)
{
  Window* window = reinterpret_cast<Window*> (clientdata);
  window->emitKeyboardEvent (eid);
}


text:
/////////////////////////////////////////////////////////////////////////////////////////
//
// The MIT License (MIT)
//
// Copyright (c) 2014-2015 Keld Oelykke
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
/////////////////////////////////////////////////////////////////////////////////////////

package starkcoder.failfast.checks.objects.booleans;

/**
 * Specification grouping all Boolean check specifications.
 * <p>
 * This (or a derivative) should inherit all check methods targeting Boolean.
 * </p>
 *
 * @author Keld Oelykke
 */
public interface IObjectBooleanChecker extends IObjectBooleanSameCheck, IObjectBooleanNotSameCheck,
    IObjectBooleanEqualsCheck, IObjectBooleanNotEqualsCheck, IObjectBooleanNullCheck,
    IObjectBooleanNotNullCheck, IObjectBooleanFalseCheck, IObjectBooleanTrueCheck,
    IObjectBooleanDefaultCheck, IObjectBooleanNotDefaultCheck
{

}


text:
using System.Threading;
using System.Threading.Tasks;
using Xunit.Sdk;

namespace LightBDD.XUnit2.Implementation.Customization
{
    internal class ScenarioTestCaseRunner : XunitTestCaseRunner
    {
        public ScenarioTestCaseRunner(IXunitTestCase testCase, string displayName, string skipReason, object[] constructorArguments, object[] testMethodArguments, IMessageBus messageBus, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource)
             : base(testCase, displayName, skipReason, constructorArguments, testMethodArguments, messageBus, aggregator, cancellationTokenSource)
        {
        }

        protected override Task<RunSummary> RunTestAsync()
        {
            var runner = new ScenarioTestRunner(CreateTest(TestCase, DisplayName), MessageBus, TestClass,
                ConstructorArguments, TestMethod, TestMethodArguments, SkipReason, BeforeAfterAttributes,
                new ExceptionAggregator(Aggregator), CancellationTokenSource);

            return runner.RunScenarioAsync();
        }
    }
}


text:
<!DOCTYPE html>

	<meta charset="utf-8" />
	<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
	<link href="//netdna.bootstrapcdn.com/twitter-bootstrap/2.3.2/css/bootstrap-combined.min.css" rel="stylesheet">
	<link href="//netdna.bootstrapcdn.com/font-awesome/3.2.1/css/font-awesome.css" rel="stylesheet">
	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
	<link type="text/css" href="/css/battlemap.css" rel="stylesheet" />
	<link type="text/css" href="/css/persona-buttons.css" rel="stylesheet" />
	<link type="text/css" href="/css/override.css" rel="stylesheet" />

	{% block eager_page_script %}
	{% endblock %}
	{% block page_style %}
	{% endblock %}

	<title>RPG Battle Map{% block title %}{% endblock %}</title>

	{% block body_head %}

	{% endblock %}

	{% block body_content %}

	{% block content %}
	{{ content }}
	{% endblock %}

	{% endblock %}

	{% block page_scripts %}
	{% endblock %}

{% comment %}
{# -*- vim: set ft=htmldjango: -- vim modeline -*- #}{% endcomment %}


text:
from sandbox.rocky.tf.q_functions.base import QFunction
import sandbox.rocky.tf.core.layers as L
import tensorflow as tf
from rllab.core.serializable import Serializable
from sandbox.rocky.tf.core.layers_powered import LayersPowered
from sandbox.rocky.tf.misc import tensor_utils
from sandbox.rocky.tf.policies.base import StochasticPolicy

class DiscreteMLPQFunction(QFunction, LayersPowered, Serializable):
    def __init__(
            self,
            env_spec,
            name='qnet',
            hidden_sizes=(32, 32),
            hidden_nonlinearity=tf.nn.relu,
            action_merge_layer=-2,
            output_nonlinearity=None,
            hidden_W_init=L.XavierUniformInitializer(),
            hidden_b_init=L.ZerosInitializer(),
            output_W_init=L.XavierUniformInitializer(),
            output_b_init=L.ZerosInitializer(),
            c=1.0, # temperature variable for stochastic policy
            bn=False):
        Serializable.quick_init(self, locals())

        assert env_spec.action_space.is_discrete
        self._n = env_spec.action_space.n
        self._c = c
        self._env_spec = env_spec

        with tf.variable_scope(name):
            l_obs = L.InputLayer(shape=(None, env_spec.observation_space.flat_dim), name="obs")
            l_action = L.InputLayer(shape=(None, env_spec.action_space.n), var_type=tf.uint8, name="actions")

            n_layers = len(hidden_sizes) + 1

            l_hidden = l_obs

            for idx, size in enumerate(hidden_sizes):
                if bn:
                    l_hidden = L.batch_norm(l_hidden)

                l_hidden = L.DenseLayer(
                    l_hidden,
                    num_units=size,
                    W=hidden_W_init,
                    b=hidden_b_init,
                    nonlinearity=hidden_nonlinearity,
                    name="h%d" % (idx + 1)
                )

            l_output_vec = L.DenseLayer(
                l_hidden,
                num_units=env_spec.action_space.n,
                W=output_W_init,
                b=output_b_init,
                nonlinearity=output_nonlinearity,
                name="output"
            )

            output_vec_var = L.get_output(l_output_vec, deterministic=True)

            output_var = tf.reduce_sum(output_vec_var*tf.to_float(l_action.input_var), 1)

            self._f_qval = tensor_utils.compile_function([l_obs.input_var, l_action.input_var], output_var)
            self._f_qval_vec = tensor_utils.compile_function([l_obs.input_var], output_vec_var)
            self._output_vec_layer = l_output_vec
            self._obs_layer = l_obs
            self._action_layer = l_action
            self._output_nonlinearity = output_nonlinearity

            self.init_policy()

            LayersPowered.__init__(self, [l_output_vec])

    def init_policy(self):
        pass

    def get_qval(self, observations, actions):
        return self._f_qval(observations, actions)

    def _get_qval_sym(self, obs_var, action_var, **kwargs):
        output_vec = L.get_output(
            self._output_vec_layer,
            {self._obs_layer: obs_var},
            **kwargs
        )
        return tf.reduce_sum(output_vec * tf.to_float(action_var), 1), output_vec

    def get_qval_sym(self, obs_var, action_var, **kwargs):
        return self._get_qval_sym(obs_var, action_var, **kwargs)[0]

    def get_e_qval(self, observations, policy):
        if isinstance(policy, StochasticPolicy):
            agent_info = policy.dist_info(observations)
            action_vec = agent_info['prob']
        else: raise NotImplementedError
        output_vec = self._f_qval_vec(observations)
        qvals = output_vec * action_vec
        return qvals.sum(axis=1)

    def get_e_qval_sym(self, obs_var, policy, **kwargs):
        if isinstance(policy, StochasticPolicy):
            agent_info = policy.dist_info_sym(obs_var)
            action_vec = agent_info['prob']
        else: raise NotImplementedError
        output_vec = L.get_output(
            self._output_vec_layer,
            {self._obs_layer: obs_var},
            **kwargs
        )
        return tf.reduce_sum(output_vec * action_vec, 1)

    def get_cv_sym(self, obs_var, action_var, policy, **kwargs):
        if isinstance(policy, StochasticPolicy):
            agent_info = policy.dist_info_sym(obs_var)
            action_vec = agent_info['prob']
        else: raise NotImplementedError
        qvals, output_vec = self._get_qval_sym(obs_var, action_var, deterministic=True, **kwargs)
        vvals = tf.reduce_sum(output_vec * action_vec, 1)
        return qvals - vvals


text:
<?php

class Obj extends stdClass {

  /**
   * Constructor
   *
   * @param array $data
   */
  public function __construct($data = array()) {
    foreach($data as $key => $val) {
      if(!is_string($key) || str::length($key) === 0) continue;
      $this->{$key} = $val;
    }
  }

  /**
   * Magic getter
   *
   * @param string $method
   * @param array $arguments
   * @return mixed
   */
  public function __call($method, $arguments) {
    return isset($this->$method) ? $this->$method : null;
  }

  /**
   * Attribute setter
   *
   * @param string $key
   * @param mixed $value
   */
  public function set($key, $value) {
    $this->$key = $value;
  }

  /**
   * Attribute getter
   *
   * @param string $key
   * @param mixed $default
   * @return mixed
   */
  public function get($key, $default = null) {
    return isset($this->$key) ? $this->$key : $default;
  }

  /**
   * Converts the object to an array
   *
   * @return array
   */
  public function toArray() {
    return (array)$this;
  }

  /**
   * Improved var_dump() output
   *
   * @return array
   */
  public function __debuginfo() {
    return $this->toArray();
  }

}


text:
namespace SST.Core
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reflection;
    using System.Text;
    using SST.Enums;
    using SST.Model;
    using SST.Util;

    /// <summary>
    /// Class that contains important information about the server on which the bot is loaded.
    /// </summary>
    public class ServerInfo
    {
        private readonly Type _logClassType = MethodBase.GetCurrentMethod().DeclaringType;
        private readonly string _logPrefix = "[CORE]";

        /// <summary>
        /// Initializes a new instance of the <see cref="ServerInfo"/> class.
        /// </summary>
        public ServerInfo()
        {
            // Ignoring case is very important here
            CurrentPlayers =
                new Dictionary<string, PlayerInfo>(StringComparer.InvariantCultureIgnoreCase);
            EndOfGameRedTeam = new List<string>();
            EndOfGameBlueTeam = new List<string>();
        }

        /// <summary>
        /// Gets the current players.
        /// </summary>
        /// <value>The current players.</value>
        public Dictionary<string, PlayerInfo> CurrentPlayers { get; private set; }

        /// <summary>
        /// Gets or sets the current server address.
        /// </summary>
        /// <value>The current server address.</value>
        public string CurrentServerAddress { get; set; }

        /// <summary>
        /// Gets or sets the server's current game state.
        /// </summary>
        /// <value>The server's current gamestate.</value>
        public QlGameStates CurrentServerGameState { get; set; }

        /// <summary>
        /// Gets or sets the type of game for the current server.
        /// </summary>
        /// <value>The type of game for the current server.</value>
        public QlGameTypes CurrentServerGameType { get; set; }

        /// <summary>
        /// Gets or sets the current server identifier.
        /// </summary>
        /// <value>The current server identifier.</value>
        public string CurrentServerId { get; set; }

        /// <summary>
        /// Gets or sets the blue team at game's end.
        /// </summary>
        /// <value>The blue team at game's end.</value>
        public List<string> EndOfGameBlueTeam { get; set; }

        /// <summary>
        /// Gets or sets the red team at game's end.
        /// </summary>
        /// <value>The red team at game's end.</value>
        public List<string> EndOfGameRedTeam { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether the Quake Live client is actually connected to a
        /// server or not.
        /// </summary>
        /// <value><c>true</c> if the Quake Live client is connected to server; otherwise, <c>false</c>.</value>
        public bool IsQlConnectedToServer { get; set; }

        /// <summary>
        /// Gets or sets the player the bot has last followed (spectated), when determining accuracy
        /// data, if any.
        /// </summary>
        /// <value>
        /// The player the bot has last followed (spectated), if any, when determining accuract data.
        /// </value>
        public string PlayerFollowedForAccuracy { get; set; }

        /// <summary>
        /// Gets or sets the blue team's score.
        /// </summary>
        /// <value>The blue team's score.</value>
        public int ScoreBlueTeam { get; set; }

        /// <summary>
        /// Gets or sets the red team's score.
        /// </summary>
        /// <value>The red team's score.</value>
        public int ScoreRedTeam { get; set; }

        /// <summary>
        /// Gets the team.
        /// </summary>
        /// <param name="t">The Team enum.</param>
        /// <returns>A list of <see cref="PlayerInfo"/> objects for a given Team enum.</returns>
        public List<PlayerInfo> GetTeam(Team t)
        {
            var team = CurrentPlayers.Where(player => player.Value.Team.Equals(t))
                                     .Select(player => player.Value)
                                     .ToList();
            var sb = new StringBuilder();

            foreach (var player in team)
            {
                sb.Append(string.Format("{0}, ", player.ShortName));
            }

            Log.Write(string.Format("Internally retrieving {0} stored players for {1} team: {2}",
                team.Count, t, sb.ToString().TrimEnd(',', ' ')), _logClassType, _logPrefix);

            return team;
        }

        /// <summary>
        /// Determines whether the active player count on the server is an even number.
        /// </summary>
        /// <returns>
        /// <c>true</c> if the server's active (team red or team blue) player count is an even
        /// number; otherwise <c>false</c>.
        /// </returns>
        public bool HasEvenTeams()
        {
            return (((GetTeam(Team.Red).Count) + (GetTeam(Team.Blue).Count))) % 2 == 0;
        }

        /// <summary>
        /// Determines whether the specified player is an active player (on red or blue team).
        /// </summary>
        /// <param name="player">The player.</param>
        /// <returns><c>true</c> if the specified player is an active player, otherwise <c>false</c></returns>
        public bool IsActivePlayer(string player)
        {
            if (!Helpers.KeyExists(player, CurrentPlayers))
            {
                return false;
            }
            return CurrentPlayers[player].Team == Team.Blue ||
                   CurrentPlayers[player].Team == Team.Red;
        }

        /// <summary>
        /// Determines whether the current gametype is a team-based game.
        /// </summary>
        /// <returns><c>true</c> if the current gametype is a team-based game; otherwise <c>false</c></returns>
        public bool IsATeamGame()
        {
            return Helpers.IsQuakeLiveTeamGame(CurrentServerGameType);
        }

        /// <summary>
        /// Determines whether the server's current game type is a type supported by QLRanks.
        /// </summary>
        /// <returns>
        /// <c>true</c> if the server's current gametype is supported by QLRanks, otherwise <c>false</c>.
        /// </returns>
        public bool IsQlRanksGameType()
        {
            return CurrentServerGameType == QlGameTypes.Ca
                   || CurrentServerGameType == QlGameTypes.Ctf
                   || CurrentServerGameType == QlGameTypes.Duel
                   || CurrentServerGameType == QlGameTypes.Ffa
                   || CurrentServerGameType == QlGameTypes.Tdm;
        }

        /// <summary>
        /// Resets the server information.
        /// </summary>
        public void Reset()
        {
            CurrentPlayers.Clear();
            CurrentServerGameState = QlGameStates.Unspecified;
            CurrentServerGameType = QlGameTypes.Unspecified;
            CurrentServerId = string.Empty;
            CurrentServerAddress = string.Empty;
            IsQlConnectedToServer = false;
            PlayerFollowedForAccuracy = string.Empty;
            ScoreBlueTeam = 0;
            ScoreRedTeam = 0;
            Log.Write("Reset server information.", _logClassType, _logPrefix);
        }
    }
}


text:
local busted_runner
do
  -- avoid warning during test runs caused by
  -- https://github.com/openresty/lua-nginx-module/blob/2524330e59f0a385a9c77d4d1b957476dce7cb33/src/ngx_http_lua_util.c#L810

  local traceback = require "debug".traceback

  setmetatable(_G, { __newindex = function(table, key, value) rawset(table, key, value) end })
  busted_runner = require "busted.runner"

  -- if there's more constants need to be whitelisted for test runs, add here.
  local GLOBALS_ALLOWED_IN_TEST = {
    helpers = true,
  }
  local newindex = function(table, key, value)
    rawset(table, key, value)

    local phase = ngx.get_phase()
    if phase == "init_worker" or phase == "init" then
      return
    end

    -- we check only timer phase because resty-cli runs everything in timer phase
    if phase == "timer" and GLOBALS_ALLOWED_IN_TEST[key] then
      return
    end

    local message = "writing a global lua variable " .. key ..
      " which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables " .. traceback('', 2)
    -- it's important to do print here because ngx.log is mocked below
    print(message)
  end
  setmetatable(_G, { __newindex = newindex })
end

_G.helpers = require("test.helpers")

local ffi = require("ffi")
local lua_ingress = require("lua_ingress")

-- without this we get errors such as "attempt to redefine XXX"
local old_cdef = ffi.cdef
local exists = {}
ffi.cdef = function(def)
  if exists[def] then
    return
  end
  exists[def] = true
  return old_cdef(def)
end

local old_udp = ngx.socket.udp
ngx.socket.udp = function(...)
  local socket = old_udp(...)
  socket.send = function(...)
    error("ngx.socket.udp:send please mock this to use in tests")
  end
  return socket
end

local old_tcp = ngx.socket.tcp
ngx.socket.tcp = function(...)
  local socket = old_tcp(...)
  socket.send = function(...)
    error("ngx.socket.tcp:send please mock this to use in tests")
  end
  return socket
end

ngx.log = function(...) end
ngx.print = function(...) end

lua_ingress.init_worker()

busted_runner({ standalone = false })


text:
package org.kurento.client;

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.UUID;

import javax.annotation.PreDestroy;

import org.kurento.client.internal.KmsUrlLoader;
import org.kurento.client.internal.TransactionImpl;
import org.kurento.client.internal.client.RomManager;
import org.kurento.client.internal.transport.jsonrpc.RomClientJsonRpcClient;
import org.kurento.commons.PropertiesManager;
import org.kurento.commons.exception.KurentoException;
import org.kurento.jsonrpc.client.AbstractJsonRpcClientWebSocket;
import org.kurento.jsonrpc.client.JsonRpcClient;
import org.kurento.jsonrpc.client.JsonRpcClientNettyWebSocket;
import org.kurento.jsonrpc.message.Request;
import org.kurento.jsonrpc.message.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.base.StandardSystemProperty;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;

/**
 * Factory to create {@link MediaPipeline} in the media server.
 *
 * @author Luis López (llopez@gsyc.es)
 * @author Ivan Gracia (igracia@gsyc.es)
 * @author Micael Gallego (micael.gallego@gmail.com)
 * @since 2.0.0
 */
public class KurentoClient {

  private static final int KEEPALIVE_TIME =
	      PropertiesManager.getProperty("kurento.client.keepAliveTime", 240000);

  private static final long WARN_CONNECTION_TIME = 5000;

  private static Logger log = LoggerFactory.getLogger(KurentoClient.class);

  protected RomManager manager;

  private long requesTimeout =
      PropertiesManager.getProperty("kurento.client.requestTimeout", 10000);

  private long connectionTimeout =
      PropertiesManager.getProperty("kurento.client.connectionTimeout", 5000);

  private String id;

  private ServerManager serverManager;

  private JsonRpcClient client;

  private static KmsUrlLoader kmsUrlLoader;

  private String label;

  private boolean destroyed = false;

  public static synchronized String getKmsUrl(String id, Properties properties) {

    if (properties == null) {
      properties = new Properties();
    }

    if (kmsUrlLoader == null) {

      Path configFile =
          Paths.get(StandardSystemProperty.USER_HOME.value(), ".kurento", "config.properties");

      kmsUrlLoader = new KmsUrlLoader(configFile);
    }

    Object load = properties.get("loadPoints");
    if (load == null) {
      return kmsUrlLoader.getKmsUrl(id);
    } else {
      if (load instanceof Number) {
        return kmsUrlLoader.getKmsUrlLoad(id, ((Number) load).intValue());
      } else {
        return kmsUrlLoader.getKmsUrlLoad(id, Integer.parseInt(load.toString()));
      }
    }
  }

  private void setId(String id) {
    this.id = id;
  }

  public static KurentoClient create() {
    return create(new Properties());
  }

  public static KurentoClient create(Properties properties) {
    String id = UUID.randomUUID().toString();
    KurentoClient client = create(getKmsUrl(id, properties), properties);
    client.setId(id);
    return client;
  }

  public static KurentoClient create(String websocketUrl) {
    return create(websocketUrl, new Properties());
  }

  public static KurentoClient create(String websocketUrl, Properties properties) {
    log.debug("Connecting to kms in {}", websocketUrl);
    JsonRpcClientNettyWebSocket client = new JsonRpcClientNettyWebSocket(websocketUrl);
    configureJsonRpcClient(client);
    return new KurentoClient(client);
  }

  protected static void configureJsonRpcClient(AbstractJsonRpcClientWebSocket client) {
    client.enableHeartbeat(KEEPALIVE_TIME);
    client.setTryReconnectingForever(true);
    updateLabel(client, null);
    client.setSendCloseMessage(true);
  }

  public static KurentoClient create(String websocketUrl, KurentoConnectionListener listener) {
    return create(websocketUrl, listener, new Properties());
  }

  public static KurentoClient create(Properties properties, KurentoConnectionListener listener) {
    String id = UUID.randomUUID().toString();
    KurentoClient client = create(getKmsUrl(id, properties), listener, properties);
    client.setId(id);
    return client;
  }

  public static KurentoClient create(String websocketUrl, KurentoConnectionListener listener,
      Properties properties) {
    log.debug("Connecting to KMS in {}", websocketUrl);
    JsonRpcClientNettyWebSocket client = new JsonRpcClientNettyWebSocket(websocketUrl,
        JsonRpcConnectionListenerKurento.create(listener));
    configureJsonRpcClient(client);
    return new KurentoClient(client);
  }

  protected static KurentoClient create(String kmsWsUri, Properties properties,
      final Handler connectedHandler, final Handler connectionFailedHandler,
      final Handler reconnectingHandler, final Handler disconnectedHandler,
      final ReconnectedHandler reconnectedHandler, Long tryReconnectingMaxTime,
      Long connectionTimeout) {

    String clientId = null;
    if (kmsWsUri == null) {
      clientId = UUID.randomUUID().toString();
      kmsWsUri = getKmsUrl(clientId, properties);
    }

    KurentoClient kurentoClient = null;

    log.debug("Connecting to KMS in {}", kmsWsUri);

    JsonRpcClientNettyWebSocket client = new JsonRpcClientNettyWebSocket(kmsWsUri);

    if (connectionTimeout != null) {
      client.setConnectionTimeout(connectionTimeout.intValue());
    }

    if (connectedHandler != null) {
      client.onConnected(new org.kurento.jsonrpc.client.Handler() {
        @Override
        public void run() {
          connectedHandler.run();
        }
      });
    }

    if (connectionFailedHandler != null) {
      client.onConnectionFailed(new org.kurento.jsonrpc.client.Handler() {
        @Override
        public void run() {
          connectionFailedHandler.run();
        }
      });
    }

    if (reconnectingHandler != null) {
      client.onReconnecting(new org.kurento.jsonrpc.client.Handler() {
        @Override
        public void run() {
          reconnectingHandler.run();
        }
      });
    }

    if (disconnectedHandler != null) {
      client.onDisconnected(new org.kurento.jsonrpc.client.Handler() {
        @Override
        public void run() {
          disconnectedHandler.run();
        }
      });
    }

    if (reconnectedHandler != null) {
      client.onReconnected(new org.kurento.jsonrpc.client.ReconnectedHandler() {
        @Override
        public void run(boolean sameServer) {
          reconnectedHandler.run(sameServer);
        }
      });
    }

    configureJsonRpcClient(client);

    if (tryReconnectingMaxTime != null) {
      client.setTryReconnectingMaxTime(tryReconnectingMaxTime);
    }

    kurentoClient = new KurentoClient(client);

    if (clientId != null) {
      kurentoClient.setId(clientId);
    }

    return kurentoClient;
  }

  protected KurentoClient(JsonRpcClient client) {
	  this(client, true);
  }

  protected KurentoClient(JsonRpcClient client, boolean overrideClientTimeouts) {
    this.client = client;
    this.manager = new RomManager(new RomClientJsonRpcClient(client));
    if (overrideClientTimeouts) {
      client.setRequestTimeout(requesTimeout);
      client.setConnectionTimeout((int) connectionTimeout);
    }
    if (client instanceof AbstractJsonRpcClientWebSocket) {
      ((AbstractJsonRpcClientWebSocket) client).enableHeartbeat(KEEPALIVE_TIME);
    }
    try {
      long start = System.currentTimeMillis();
      client.connect();
      long duration = System.currentTimeMillis() - start;

      if (duration > WARN_CONNECTION_TIME) {
        log.warn("Connected to KMS in {} millis (> {} millis)", duration, WARN_CONNECTION_TIME);
      }

    } catch (Exception e) {
      throw new KurentoException("Exception connecting to KMS", e);
    }
  }

  /**
   * Creates a new {@link MediaPipeline} in the media server.
   *
   * @return The media pipeline
   */
  public MediaPipeline createMediaPipeline() {
    return new AbstractBuilder<MediaPipeline>(MediaPipeline.class, manager).build();
  }

  /**
   * Creates a new {@link MediaPipeline} in the media server.
   *
   * @param cont
   *          An asynchronous callback handler. If the element was successfully created, the
   *          {@code onSuccess} method from the handler will receive a {@link MediaPipeline} stub
   *          from the media server.
   * @throws KurentoException
   *
   */
  public void createMediaPipeline(final Continuation<MediaPipeline> cont) throws KurentoException {
    new AbstractBuilder<MediaPipeline>(MediaPipeline.class, manager).buildAsync(cont);
  }

  public MediaPipeline createMediaPipeline(Transaction tx) {
    return new AbstractBuilder<MediaPipeline>(MediaPipeline.class, manager).build(tx);
  }

  /**
   * Creates a new {@link MediaPipeline} in the media server.
   *
   * @return The media pipeline
   */
  public MediaPipeline createMediaPipeline(Properties properties) {
    return new AbstractBuilder<MediaPipeline>(MediaPipeline.class, manager)
        .withProperties(properties).build();
  }

  /**
   * Creates a new {@link MediaPipeline} in the media server.
   *
   * @param cont
   *          An asynchronous callback handler. If the element was successfully created, the
   *          {@code onSuccess} method from the handler will receive a {@link MediaPipeline} stub
   *          from the media server.
   * @throws KurentoException
   *
   */
  public void createMediaPipeline(Properties properties, final Continuation<MediaPipeline> cont)
      throws KurentoException {
    new AbstractBuilder<MediaPipeline>(MediaPipeline.class, manager).withProperties(properties)
        .buildAsync(cont);
  }

  public MediaPipeline createMediaPipeline(Transaction tx, Properties properties) {
    return new AbstractBuilder<MediaPipeline>(MediaPipeline.class, manager)
        .withProperties(properties).build(tx);
  }

  @PreDestroy
  public void destroy() {
	this.destroyed = true;
    if (isClosed()) {
      log.debug("{} KurentoClient already closed", label);
      return;
    }
    log.debug("Closing KurentoClient");
    manager.destroy();
    try {
      client.close();
    } catch (IOException e) {
      log.error("Error while closing KurentoClient", e);
    }
    if (kmsUrlLoader != null) {
      kmsUrlLoader.clientDestroyed(id);
    }
  }

  public boolean isClosed() {
    return manager.getRomClient().isClosed();
  }

  public boolean isDestroyed() {
    return this.destroyed;
  }

  public static KurentoClient createFromJsonRpcClient(JsonRpcClient jsonRpcClient) {
    return new KurentoClient(jsonRpcClient);
  }

  public static KurentoClient createFromJsonRpcClientHonoringClientTimeouts(JsonRpcClient jsonRpcClient) {
    return new KurentoClient(jsonRpcClient, false);
  }

  public Transaction beginTransaction() {
    return new TransactionImpl(manager);
  }

  public ServerManager getServerManager() {
    if (serverManager == null) {
      serverManager = getById("manager_ServerManager", ServerManager.class);
    }
    return serverManager;
  }

  public <T extends KurentoObject> T getById(String id, Class<T> clazz) {
    return manager.getById(id, clazz);
  }

  public String getSessionId() {
    return client.getSession().getSessionId();
  }

  public void setLabel(String label) {
    this.label = label;
    updateLabel(client, label);
  }

  public String getLabel() {
    return label;
  }

  private static void updateLabel(JsonRpcClient client, String label) {
    String clientLabel = "KurentoClient";
    if (label != null) {
      clientLabel += ":" + label;
    }
    client.setLabel(clientLabel);
  }

  public Response<JsonElement> sendJsonRpcRequest(Request<JsonObject> request) throws IOException {
	  return client.sendRequest(request);
  }
}


text:
<?php defined('SYSPATH') or die('No direct script access.');

class Kohana_Database_Query_Builder_Join extends Database_Query_Builder {

	// Type of JOIN
	protected $_type;

	// JOIN ...
	protected $_table;

	// ON ...
	protected $_on = array();

	// USING ...
	protected $_using = array();

	/**
	 * Creates a new JOIN statement for a table. Optionally, the type of JOIN
	 * can be specified as the second parameter.
	 *
	 * @param   mixed   column name or array($column, $alias) or object
	 * @param   string  type of JOIN: INNER, RIGHT, LEFT, etc
	 * @return  void
	 */
	public function __construct($table, $type = NULL)
	{
		// Set the table to JOIN on
		$this->_table = $table;

		if ($type !== NULL)
		{
			// Set the JOIN type
			$this->_type = (string) $type;
		}
	}

	/**
	 * Adds a new condition for joining.
	 *
	 * @param   mixed   column name or array($column, $alias) or object
	 * @param   string  logic operator
	 * @param   mixed   column name or array($column, $alias) or object
	 * @return  $this
	 */
	public function on($c1, $op, $c2)
	{
		if ( ! empty($this->_using))
		{
			throw new Kohana_Exception('JOIN ... ON ... cannot be combined with JOIN ... USING ...');
		}

		$this->_on[] = array($c1, $op, $c2);

		return $this;
	}

	/**
	 * Adds a new condition for joining.
	 *
	 * @param   string  column name
	 * @param   ...
	 * @return  $this
	 */
	public function using($columns)
	{
		if ( ! empty($this->_on))
		{
			throw new Kohana_Exception('JOIN ... ON ... cannot be combined with JOIN ... USING ...');
		}

		$columns = func_get_args();

		$this->_using = array_merge($this->_using, $columns);

		return $this;
	}

	/**
	 * Compile the SQL partial for a JOIN statement and return it.
	 *
	 * @param   object  Database instance
	 * @return  string
	 */
	public function compile(Database $db)
	{
		if ($this->_type)
		{
			$sql = strtoupper($this->_type).' JOIN';
		}
		else
		{
			$sql = 'JOIN';
		}

		// Quote the table name that is being joined
		$sql .= ' '.$db->quote_table($this->_table);

		if ( ! empty($this->_using))
		{
			// Quote and concat the columns
			$sql .= ' USING ('.implode(', ', array_map(array($db, 'quote_column'), $this->_using)).')';
		}
		else
		{
			$conditions = array();
			foreach ($this->_on as $condition)
			{
				// Split the condition
				list($c1, $op, $c2) = $condition;

				if ($op)
				{
					// Make the operator uppercase and spaced
					$op = ' '.strtoupper($op);
				}

				// Quote each of the columns used for the condition
				$conditions[] = $db->quote_column($c1).$op.' '.$db->quote_column($c2);
			}

			// Concat the conditions "... AND ..."
			$sql .= ' ON ('.implode(' AND ', $conditions).')';
		}

		return $sql;
	}

	public function reset()
	{
		$this->_type =
		$this->_table = NULL;

		$this->_on = array();
	}

} // End Database_Query_Builder_Join


text:
'use strict';

/**
 * Module dependencies.
 */
var passport = require('passport');

module.exports = function (app) {
  // User Routes
  var users = require('../controllers/users.server.controller');

  // Setting up the users password api
  app.route('/api/auth/forgot').post(users.forgot);
  app.route('/api/auth/reset/:token').get(users.validateResetToken);
  app.route('/api/auth/reset/:token').post(users.reset);

  // Setting up the users authentication api
  app.route('/api/auth/signup').post(users.signup);
  app.route('/api/auth/signin').post(users.signin);
  app.route('/api/auth/signout').get(users.signout);
};


text:
package com.seleniumtests.webelements;

import org.openqa.selenium.By;

import com.seleniumtests.core.TestLogging;

public class CheckBoxElement extends HtmlElement {

    public CheckBoxElement(final String label, final By by) {
        super(label, by);
    }

    @Override
    public void check() {
        TestLogging.logWebStep("check " + toHTML(), false);
        super.check();
    }

    @Override
    public void uncheck() {
        TestLogging.logWebStep("uncheck " + toHTML(), false);
        super.uncheck();
    }

    @Override
    public void click() {
        TestLogging.logWebStep("click on " + toHTML(), false);
        super.click();
    }

    public boolean isSelected() {
        findElement();
        return element.isSelected();
    }
}


text:
  <legend>请输入信息:</legend>
  <input type="number" class="am-form-field" ng-model="inputText" />
  <legend></legend>

    <button type="button" class="ngdialog-button ngdialog-button-secondary" ng-click="closeThisDialog()">取消</button>
    <button type="button" class="ngdialog-button ngdialog-button-primary" ng-click="confirm(inputText)">确认</button>


text:
<resources>
    <!-- Default screen margins, per the Android Design guidelines. -->
    <integer name="ean_size">13</integer>
    <integer name="ean_width">8</integer>
    <dimen name="head_line">24sp</dimen>
    <dimen name="small_fontsize">12sp</dimen>

    <!-- Per the design guidelines, navigation drawers should be between 240dp and 320dp:
         https://developer.android.com/design/patterns/navigation-drawer.html -->
    <dimen name="navigation_drawer_width">240dp</dimen>
</resources>


text:
title: OneDrive for Business
inshort: Opslag van persoonlijke bestanden [Dropbox]
translator: Microsoft Cognitive Services
---

OneDrive for Business (OD4B) is het bestand met persoonlijke opslaggebied dat elke werknemer met een Office 365-abonnement krijgt. OD4B is nuttig voor het opslaan van persoonlijke (maar werkgerelateerde) bestanden, eerste document concepten en bestanden die u nodig hebt om te delen met een zeer kleine groep mensen.

OD4B is over het algemeen bedoeld voor u voor het opslaan van bestanden die alleen u nodig hebt. Het kan het goed voor het houden van prestatiebeoordelingen, lokale kopieën van de documenten van de voordelen, vakantie-planners, persoonlijke notities, reizen ontvangsten en meer. Veel OD4B gebruikers ook profiteren van de privacy biedt en beginnen hun document concepten in OD4B; Zodra ze het ontwerp hebt voltooid en input wilt, zij het bestand verplaatsen naar hun SharePoint-teamsite zodat hun collega's kunnen een bijdrage leveren en herziening.

OD4B is niet een goed hulpmiddel voor samenwerking binnen teams of tussen vele collega's, omdat de bestanden zijn specifiek voor de OD4B-gebruiker die gedeeld. Als die persoon de organisatie verlaat, kunnen deze bestanden uiteindelijk worden verwijderd en verloren. Het is ook niet ongewoon dat OD4B gebruikers die willen samenwerken machtigingen fouten maken en bieden toegang tot meer bestanden dan ze bedoeld. SharePoint, MS Teams of groepen van Outlook zijn betere platforms voor full-op samenwerking.

OD4B biedt meer dan 1 TB aan ruimte in de cloud (hoewel dit kan worden beperkt door uw beheerder) en wordt geleverd met een desktop sync tool zodat kunt u sommige of alle van uw cloud-bestanden op uw computer voor off line gebruik. Hulpmiddel van sync van de ook geeft gemakkelijk toegang tot uw bestanden rechtstreeks via File Explorer (Windows) en Finder (MacOS), rechtstreeks via de Office-apps, en kan zelfs worden toegevoegd als een bestand bron in apps zoals Adobe Acrobat.

[Bestanden op aanvraag](https://blogs.office.com/en-us/2017/05/11/introducing-onedrive-files-on-demand-and-additional-features-making-it-easier-to-access-and-share-files/), een functie uitgebracht in 2017, worden alle bestanden van de cloud in bestand Verkenner of Finder weergegeven ongeacht of ze waren eigenlijk gedownload, wat betekent dat u kunt bekijken, openen, bewerken, verplaatsen en kopiëren van bestanden op uw bureaublad, zelfs als ze nog niet zijn gedownload.

De mobiele app (iOS en Android) is top-notch en een zeer goede manier om toegang tot bestanden van Office 365 wanneer u geen toegang tot de computer hebt. Bijvoorbeeld, kunt u vrij gemakkelijk een PowerPoint-bestand presenteren direct vanaf je iPhone via een draadloos netwerk aan een conferentie kamer monitor, allemaal op de vlieg.

Middelen
---------

-[Wat is OneDrive voor
    Business?](https://support.office.com/en-us/article/What-is-OneDrive-for-Business-187f90af-056f-47c0-9656-cc0ddca7fdc2)
    \[Microsoft\]

-[Verschillen tussen de diverse OneDrive
    "ervaringen"](http://icsh.pt/OneDriveTree) \[icansharepoint
    inforgraphic\]

-[Wanneer gebruik OneDrive versus SharePoint](http://icsh.pt/DocCircleOfLife) \[icansharepoint
    inforgraphic\]

Soortgelijke toepassingen
--------------------

-OneDrive (consument)

-Google Drive

-iCloud Drive

Feedback
---------

-[OneDrive voor Business UserVoice](https://onedrive.uservoice.com/forums/262982-onedrive/category/86090-onedrive-for-business)
    \[UserVoice\]

Auteur
---------

-[Matt Wade](https://www.linkedin.com/in/thatmattwade/), Office Services MVP


text:
package schema

import (
	"reflect"
	"strings"
	"sync"

	"github.com/hashicorp/terraform/terraform"
)

// ResourceData is used to query and set the attributes of a resource.
//
// ResourceData is the primary argument received for CRUD operations on
// a resource as well as configuration of a provider. It is a powerful
// structure that can be used to not only query data, but check for changes,
// define partial state updates, etc.
//
// The most relevant methods to take a look at are Get, Set, and Partial.
type ResourceData struct {
	// Settable (internally)
	schema map[string]*Schema
	config *terraform.ResourceConfig
	state  *terraform.InstanceState
	diff   *terraform.InstanceDiff

	// Don't set
	multiReader *MultiLevelFieldReader
	setWriter   *MapFieldWriter
	newState    *terraform.InstanceState
	partial     bool
	partialMap  map[string]struct{}
	once        sync.Once
	isNew       bool
}

// getResult is the internal structure that is generated when a Get
// is called that contains some extra data that might be used.
type getResult struct {
	Value          interface{}
	ValueProcessed interface{}
	Computed       bool
	Exists         bool
	Schema         *Schema
}

var getResultEmpty getResult

// Get returns the data for the given key, or nil if the key doesn't exist
// in the schema.
//
// If the key does exist in the schema but doesn't exist in the configuration,
// then the default value for that type will be returned. For strings, this is
// "", for numbers it is 0, etc.
//
// If you want to test if something is set at all in the configuration,
// use GetOk.
func (d *ResourceData) Get(key string) interface{} {
	v, _ := d.GetOk(key)
	return v
}

// GetChange returns the old and new value for a given key.
//
// HasChange should be used to check if a change exists. It is possible
// that both the old and new value are the same if the old value was not
// set and the new value is. This is common, for example, for boolean
// fields which have a zero value of false.
func (d *ResourceData) GetChange(key string) (interface{}, interface{}) {
	o, n := d.getChange(key, getSourceState, getSourceDiff)
	return o.Value, n.Value
}

// GetOk returns the data for the given key and whether or not the key
// has been set to a non-zero value at some point.
//
// The first result will not necessarilly be nil if the value doesn't exist.
// The second result should be checked to determine this information.
func (d *ResourceData) GetOk(key string) (interface{}, bool) {
	r := d.getRaw(key, getSourceSet)
	exists := r.Exists && !r.Computed
	if exists {
		// If it exists, we also want to verify it is not the zero-value.
		value := r.Value
		zero := r.Schema.Type.Zero()

		if eq, ok := value.(Equal); ok {
			exists = !eq.Equal(zero)
		} else {
			exists = !reflect.DeepEqual(value, zero)
		}
	}

	return r.Value, exists
}

func (d *ResourceData) getRaw(key string, level getSource) getResult {
	var parts []string
	if key != "" {
		parts = strings.Split(key, ".")
	}

	return d.get(parts, level)
}

// HasChange returns whether or not the given key has been changed.
func (d *ResourceData) HasChange(key string) bool {
	o, n := d.GetChange(key)

	// If the type implements the Equal interface, then call that
	// instead of just doing a reflect.DeepEqual. An example where this is
	// needed is *Set
	if eq, ok := o.(Equal); ok {
		return !eq.Equal(n)
	}

	return !reflect.DeepEqual(o, n)
}

// Partial turns partial state mode on/off.
//
// When partial state mode is enabled, then only key prefixes specified
// by SetPartial will be in the final state. This allows providers to return
// partial states for partially applied resources (when errors occur).
func (d *ResourceData) Partial(on bool) {
	d.partial = on
	if on {
		if d.partialMap == nil {
			d.partialMap = make(map[string]struct{})
		}
	} else {
		d.partialMap = nil
	}
}

// Set sets the value for the given key.
//
// If the key is invalid or the value is not a correct type, an error
// will be returned.
func (d *ResourceData) Set(key string, value interface{}) error {
	d.once.Do(d.init)

	// If the value is a pointer to a non-struct, get its value and
	// use that. This allows Set to take a pointer to primitives to
	// simplify the interface.
	reflectVal := reflect.ValueOf(value)
	if reflectVal.Kind() == reflect.Ptr {
		if reflectVal.IsNil() {
			// If the pointer is nil, then the value is just nil
			value = nil
		} else {
			// Otherwise, we dereference the pointer as long as its not
			// a pointer to a struct, since struct pointers are allowed.
			reflectVal = reflect.Indirect(reflectVal)
			if reflectVal.Kind() != reflect.Struct {
				value = reflectVal.Interface()
			}
		}
	}

	return d.setWriter.WriteField(strings.Split(key, "."), value)
}

// SetPartial adds the key to the final state output while
// in partial state mode. The key must be a root key in the schema (i.e.
// it cannot be "list.0").
//
// If partial state mode is disabled, then this has no effect. Additionally,
// whenever partial state mode is toggled, the partial data is cleared.
func (d *ResourceData) SetPartial(k string) {
	if d.partial {
		d.partialMap[k] = struct{}{}
	}
}

func (d *ResourceData) MarkNewResource() {
	d.isNew = true
}

func (d *ResourceData) IsNewResource() bool {
	return d.isNew
}

// Id returns the ID of the resource.
func (d *ResourceData) Id() string {
	var result string

	if d.state != nil {
		result = d.state.ID
	}

	if d.newState != nil {
		result = d.newState.ID
	}

	return result
}

// ConnInfo returns the connection info for this resource.
func (d *ResourceData) ConnInfo() map[string]string {
	if d.newState != nil {
		return d.newState.Ephemeral.ConnInfo
	}

	if d.state != nil {
		return d.state.Ephemeral.ConnInfo
	}

	return nil
}

// SetId sets the ID of the resource. If the value is blank, then the
// resource is destroyed.
func (d *ResourceData) SetId(v string) {
	d.once.Do(d.init)
	d.newState.ID = v
}

// SetConnInfo sets the connection info for a resource.
func (d *ResourceData) SetConnInfo(v map[string]string) {
	d.once.Do(d.init)
	d.newState.Ephemeral.ConnInfo = v
}

// State returns the new InstanceState after the diff and any Set
// calls.
func (d *ResourceData) State() *terraform.InstanceState {
	var result terraform.InstanceState
	result.ID = d.Id()

	// If we have no ID, then this resource doesn't exist and we just
	// return nil.
	if result.ID == "" {
		return nil
	}

	// In order to build the final state attributes, we read the full
	// attribute set as a map[string]interface{}, write it to a MapFieldWriter,
	// and then use that map.
	rawMap := make(map[string]interface{})
	for k := range d.schema {
		source := getSourceSet
		if d.partial {
			source = getSourceState
			if _, ok := d.partialMap[k]; ok {
				source = getSourceSet
			}
		}

		raw := d.get([]string{k}, source)
		if raw.Exists && !raw.Computed {
			rawMap[k] = raw.Value
			if raw.ValueProcessed != nil {
				rawMap[k] = raw.ValueProcessed
			}
		}
	}
	mapW := &MapFieldWriter{Schema: d.schema}
	if err := mapW.WriteField(nil, rawMap); err != nil {
		return nil
	}

	result.Attributes = mapW.Map()
	result.Ephemeral.ConnInfo = d.ConnInfo()

	// TODO: This is hacky and we can remove this when we have a proper
	// state writer. We should instead have a proper StateFieldWriter
	// and use that.
	for k, schema := range d.schema {
		if schema.Type != TypeMap {
			continue
		}

		if result.Attributes[k] == "" {
			delete(result.Attributes, k)
		}
	}

	if v := d.Id(); v != "" {
		result.Attributes["id"] = d.Id()
	}

	return &result
}

func (d *ResourceData) init() {
	// Initialize the field that will store our new state
	var copyState terraform.InstanceState
	if d.state != nil {
		copyState = *d.state
	}
	d.newState = &copyState

	// Initialize the map for storing set data
	d.setWriter = &MapFieldWriter{Schema: d.schema}

	// Initialize the reader for getting data from the
	// underlying sources (config, diff, etc.)
	readers := make(map[string]FieldReader)
	var stateAttributes map[string]string
	if d.state != nil {
		stateAttributes = d.state.Attributes
		readers["state"] = &MapFieldReader{
			Schema: d.schema,
			Map:    BasicMapReader(stateAttributes),
		}
	}
	if d.config != nil {
		readers["config"] = &ConfigFieldReader{
			Schema: d.schema,
			Config: d.config,
		}
	}
	if d.diff != nil {
		readers["diff"] = &DiffFieldReader{
			Schema: d.schema,
			Diff:   d.diff,
			Source: &MultiLevelFieldReader{
				Levels:  []string{"state", "config"},
				Readers: readers,
			},
		}
	}
	readers["set"] = &MapFieldReader{
		Schema: d.schema,
		Map:    BasicMapReader(d.setWriter.Map()),
	}
	d.multiReader = &MultiLevelFieldReader{
		Levels: []string{
			"state",
			"config",
			"diff",
			"set",
		},

		Readers: readers,
	}
}

func (d *ResourceData) diffChange(
	k string) (interface{}, interface{}, bool, bool) {
	// Get the change between the state and the config.
	o, n := d.getChange(k, getSourceState, getSourceConfig|getSourceExact)
	if !o.Exists {
		o.Value = nil
	}
	if !n.Exists {
		n.Value = nil
	}

	// Return the old, new, and whether there is a change
	return o.Value, n.Value, !reflect.DeepEqual(o.Value, n.Value), n.Computed
}

func (d *ResourceData) getChange(
	k string,
	oldLevel getSource,
	newLevel getSource) (getResult, getResult) {
	var parts, parts2 []string
	if k != "" {
		parts = strings.Split(k, ".")
		parts2 = strings.Split(k, ".")
	}

	o := d.get(parts, oldLevel)
	n := d.get(parts2, newLevel)
	return o, n
}

func (d *ResourceData) get(addr []string, source getSource) getResult {
	d.once.Do(d.init)

	level := "set"
	flags := source & ^getSourceLevelMask
	exact := flags&getSourceExact != 0
	source = source & getSourceLevelMask
	if source >= getSourceSet {
		level = "set"
	} else if source >= getSourceDiff {
		level = "diff"
	} else if source >= getSourceConfig {
		level = "config"
	} else {
		level = "state"
	}

	var result FieldReadResult
	var err error
	if exact {
		result, err = d.multiReader.ReadFieldExact(addr, level)
	} else {
		result, err = d.multiReader.ReadFieldMerge(addr, level)
	}
	if err != nil {
		panic(err)
	}

	// If the result doesn't exist, then we set the value to the zero value
	var schema *Schema
	if schemaL := addrToSchema(addr, d.schema); len(schemaL) > 0 {
		schema = schemaL[len(schemaL)-1]
	}

	if result.Value == nil && schema != nil {
		result.Value = result.ValueOrZero(schema)
	}

	// Transform the FieldReadResult into a getResult. It might be worth
	// merging these two structures one day.
	return getResult{
		Value:          result.Value,
		ValueProcessed: result.ValueProcessed,
		Computed:       result.Computed,
		Exists:         result.Exists,
		Schema:         schema,
	}
}


text:
<?php
# Generated by the protocol buffer compiler.  DO NOT EDIT!
# source: google/cloud/dataproc/v1beta2/workflow_templates.proto

namespace Google\Cloud\Dataproc\V1beta2;

use Google\Protobuf\Internal\GPBType;
use Google\Protobuf\Internal\RepeatedField;
use Google\Protobuf\Internal\GPBUtil;

/**
 * A response to a request to list workflow templates in a project.
 *
 * Generated from protobuf message google.cloud.dataproc.v1beta2.ListWorkflowTemplatesResponse
 */
class ListWorkflowTemplatesResponse extends \Google\Protobuf\Internal\Message
{
    /**
     * Output only. WorkflowTemplates list.
     *
     * Generated from protobuf field repeated .google.cloud.dataproc.v1beta2.WorkflowTemplate templates = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
     */
    private $templates;
    /**
     * Output only. This token is included in the response if there are more
     * results to fetch. To fetch additional results, provide this value as the
     * page_token in a subsequent ListWorkflowTemplatesRequest.
     *
     * Generated from protobuf field string next_page_token = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
     */
    private $next_page_token = '';

    /**
     * Constructor.
     *
     * @param array $data {
     *     Optional. Data for populating the Message object.
     *
     *     @type \Google\Cloud\Dataproc\V1beta2\WorkflowTemplate[]|\Google\Protobuf\Internal\RepeatedField $templates
     *           Output only. WorkflowTemplates list.
     *     @type string $next_page_token
     *           Output only. This token is included in the response if there are more
     *           results to fetch. To fetch additional results, provide this value as the
     *           page_token in a subsequent ListWorkflowTemplatesRequest.
     * }
     */
    public function __construct($data = NULL) {
        \GPBMetadata\Google\Cloud\Dataproc\V1Beta2\WorkflowTemplates::initOnce();
        parent::__construct($data);
    }

    /**
     * Output only. WorkflowTemplates list.
     *
     * Generated from protobuf field repeated .google.cloud.dataproc.v1beta2.WorkflowTemplate templates = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
     * @return \Google\Protobuf\Internal\RepeatedField
     */
    public function getTemplates()
    {
        return $this->templates;
    }

    /**
     * Output only. WorkflowTemplates list.
     *
     * Generated from protobuf field repeated .google.cloud.dataproc.v1beta2.WorkflowTemplate templates = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
     * @param \Google\Cloud\Dataproc\V1beta2\WorkflowTemplate[]|\Google\Protobuf\Internal\RepeatedField $var
     * @return $this
     */
    public function setTemplates($var)
    {
        $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Google\Cloud\Dataproc\V1beta2\WorkflowTemplate::class);
        $this->templates = $arr;

        return $this;
    }

    /**
     * Output only. This token is included in the response if there are more
     * results to fetch. To fetch additional results, provide this value as the
     * page_token in a subsequent ListWorkflowTemplatesRequest.
     *
     * Generated from protobuf field string next_page_token = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
     * @return string
     */
    public function getNextPageToken()
    {
        return $this->next_page_token;
    }

    /**
     * Output only. This token is included in the response if there are more
     * results to fetch. To fetch additional results, provide this value as the
     * page_token in a subsequent ListWorkflowTemplatesRequest.
     *
     * Generated from protobuf field string next_page_token = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
     * @param string $var
     * @return $this
     */
    public function setNextPageToken($var)
    {
        GPBUtil::checkString($var, True);
        $this->next_page_token = $var;

        return $this;
    }

}


text:
import * as React from 'react'
import { Link } from 'react-router-dom'

import { buildFiltersUrl, FILTER_OFF } from '../../filters'
import { Icon } from '@opentrons/components'
import styles from './styles.css'

import { CLEAR_FILTERS } from '../../localization'

import type { FilterParams } from '../../types'

export type FilterResetProps = {|
  filters: FilterParams,
|}

export function FilterReset(props: FilterResetProps): React.Node {
  const { filters } = props
  // TODO (ka 2019-3-09):Should this be moved to Sidebar?
  const { manufacturer, category } = filters
  const filtersCleared = manufacturer === FILTER_OFF && category === FILTER_OFF
  if (filtersCleared) return null

  return (
    <Link
      to={buildFiltersUrl({ ...filters, category: 'all', manufacturer: 'all' })}
      className={styles.filter_reset_link}
    >
      <Icon name="close" className={styles.filter_reset_icon} />
      {CLEAR_FILTERS}
    </Link>
  )
}


text:
package javax.servlet.jsp.tagext;

/**
 * Tag information for a tag file in a Tag Library;
 * This class is instantiated from the Tag Library Descriptor file (TLD)
 * and is available only at translation time.
 *
 * @since 2.0
 */
public class TagFileInfo {

    /**
     * Constructor for TagFileInfo from data in the JSP 2.0 format for TLD.
     * This class is to be instantiated only from the TagLibrary code
     * under request from some JSP code that is parsing a
     * TLD (Tag Library Descriptor).
     *
     * Note that, since TagLibraryInfo reflects both TLD information
     * and taglib directive information, a TagFileInfo instance is
     * dependent on a taglib directive.  This is probably a
     * design error, which may be fixed in the future.
     *
     * @param name The unique action name of this tag
     * @param path Where to find the .tag file implementing this
     *     action, relative to the location of the TLD file.
     * @param tagInfo The detailed information about this tag, as parsed
     *     from the directives in the tag file.
     */
    public TagFileInfo( String name, String path, TagInfo tagInfo ) {
        this.name = name;
        this.path = path;
        this.tagInfo = tagInfo;
    }

    /**
     * The unique action name of this tag.
     *
     * @return The (short) name of the tag.
     */
    public String getName() {
        return name;
    }

    /**
     * Where to find the .tag file implementing this action.
     *
     * @return The path of the tag file, relative to the TLD, or "." if
     *     the tag file was defined in an implicit tag file.
     */
    public String getPath() {
        return path;
    }

    /**
     * Returns information about this tag, parsed from the directives
     * in the tag file.
     *
     * @return a TagInfo object containing information about this tag
     */
    public TagInfo getTagInfo() {
        return tagInfo;
    }

    // private fields for 2.0 info
    private final String name;
    private final String path;
    private final TagInfo tagInfo;
}


text:
package org.inaetics.ails.impl.server.location.provider;

import java.util.Properties;

import org.apache.felix.dm.DependencyActivatorBase;
import org.apache.felix.dm.DependencyManager;
import org.inaetics.ails.api.server.location.provider.LocationProvider;
import org.inaetics.ails.api.server.streaming_profile.service.StreamingProfileService;
import org.inaetics.ails.api.server.user.extended_datastore.UserLocationDataStore;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.service.remoteserviceadmin.RemoteConstants;

/**
 * The LocationProviderServiceActivator starts a {@link UserLocationProviderService} as the
 * {@link LocationProvider}.
 *
 * @author L. Buit, N. Korthout, J. Naus
 * @version 0.1.2
 * @since 10-11-2015
 */
public class LocationProviderServiceActivator extends DependencyActivatorBase {

    @Override
    public void init(BundleContext context, DependencyManager manager) throws Exception {
        manager.add(createComponent().setInterface(LocationProvider.class.getName(), null)
                .setImplementation(UserLocationProviderService.class).add(createServiceDependency()
                        .setService(UserLocationDataStore.class)
                        .setRequired(true)));
    }

}


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#457b9d</color>
    <color name="colorPrimaryDark">#1d3557</color>
    <color name="colorAccent">#a8dadc</color>
</resources>


text:
package com.pie.tlatoani.Tablist.Array;

import ch.njol.skript.classes.Changer;
import ch.njol.skript.lang.Expression;
import ch.njol.skript.lang.SkriptParser;
import ch.njol.skript.lang.util.SimpleExpression;
import ch.njol.util.Kleenean;
import ch.njol.util.coll.CollectionUtils;
import com.pie.tlatoani.Skin.Skin;
import com.pie.tlatoani.Tablist.Tab;
import com.pie.tlatoani.Tablist.Tablist;
import com.pie.tlatoani.Tablist.Group.TablistProvider;
import com.pie.tlatoani.Core.Static.MathUtil;
import com.pie.tlatoani.Core.Static.OptionalUtil;
import org.bukkit.event.Event;

import java.util.Optional;

/**
 * Created by Tlatoani on 7/25/16.
 */
public class ExprIconOfArrayTab extends SimpleExpression<Skin> {
    private Expression<Number> column;
    private Expression<Number> row;
    private TablistProvider tablistProvider;

    @Override
    protected Skin[] get(Event event) {
        int column = Optional.ofNullable(this.column.getSingle(event)).map(Number::intValue).orElse(-1);
        int row = Optional.ofNullable(this.row.getSingle(event)).map(Number::intValue).orElse(-1);
        return tablistProvider
                .view(event)
                .map(tablist -> OptionalUtil
                        .cast(tablist.getSupplementaryTablist(), ArrayTablist.class)
                        .filter(arrayTablist -> MathUtil.isInRange(1, column, arrayTablist.getColumns()))
                        .filter(arrayTablist -> MathUtil.isInRange(1, row, arrayTablist.getRows()))
                        .map(arrayTablist -> arrayTablist.getTab(column, row))
                        .flatMap(Tab::getIcon)
                        .orElse(null))
                .toArray(Skin[]::new);
    }

    @Override
    public boolean isSingle() {
        return tablistProvider.isSingle();
    }

    @Override
    public Class<? extends Skin> getReturnType() {
        return Skin.class;
    }

    @Override
    public String toString(Event event, boolean b) {
        return tablistProvider.toString("icon of array tab " + column + ", " + row + " [for %]");
    }

    @Override
    public boolean init(Expression<?>[] expressions, int i, Kleenean kleenean, SkriptParser.ParseResult parseResult) {
        column = (Expression<Number>) expressions[0];
        row = (Expression<Number>) expressions[1];
        tablistProvider = TablistProvider.of(expressions, 2);
        return true;
    }

    public void change(Event event, Object[] delta, Changer.ChangeMode mode) {
        Skin value = mode == Changer.ChangeMode.SET ? (Skin) delta[0] : null;
        int column = Optional.ofNullable(this.column.getSingle(event)).map(Number::intValue).orElse(-1);
        int row = Optional.ofNullable(this.row.getSingle(event)).map(Number::intValue).orElse(-1);
        for (Tablist tablist : tablistProvider.get(event)) {
            if (tablist.getSupplementaryTablist() instanceof ArrayTablist) {
                ArrayTablist arrayTablist = (ArrayTablist) tablist.getSupplementaryTablist();
                if (MathUtil.isInRange(1, column, arrayTablist.getColumns()) && MathUtil.isInRange(1, row, arrayTablist.getRows())) {
                    arrayTablist.getTab(column, row).setIcon(value);
                }
            }
        }
    }

    public Class<?>[] acceptChange(final Changer.ChangeMode mode) {
        if (mode == Changer.ChangeMode.SET || mode == Changer.ChangeMode.RESET) {
            return CollectionUtils.array(Skin.class);
        }
        return null;
    }
}