text:
package org.apache.uima.collection.impl.metadata.cpe;

import org.apache.uima.collection.metadata.CpeCheckpoint;
import org.apache.uima.collection.metadata.CpeConfiguration;
import org.apache.uima.collection.metadata.CpeDescriptorException;
import org.apache.uima.collection.metadata.CpeTimer;
import org.apache.uima.collection.metadata.OutputQueue;
import org.apache.uima.resource.metadata.impl.MetaDataObject_impl;
import org.apache.uima.resource.metadata.impl.PropertyXmlInfo;
import org.apache.uima.resource.metadata.impl.XmlizationInfo;

/**
 * The Class CpeConfigurationImpl.
 */
public class CpeConfigurationImpl extends MetaDataObject_impl implements CpeConfiguration {

  /** The Constant serialVersionUID. */
  private static final long serialVersionUID = 1153815602567127240L;

  /** The start at. */
  private String startAt;

  /** The num 2 process. */
  private long num2Process;

  /** The checkpoint. */
  private CpeCheckpoint checkpoint;

  /** The timer impl. */
  private String timerImpl;

  /** The deploy as. */
  private String deployAs;

  /** The output queue. */
  private OutputQueue outputQueue;

  /**
   * Instantiates a new cpe configuration impl.
   */
  public CpeConfigurationImpl() {
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#setDeployment(java.lang.String)
   */
  @Override
  public void setDeployment(String aDeploy) throws CpeDescriptorException {
    deployAs = aDeploy;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#getDeployment()
   */
  @Override
  public String getDeployment() {
    return deployAs;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#setNumToProcess(int)
   */
  @Override
  public void setNumToProcess(int aNumToProcess) throws CpeDescriptorException {
    num2Process = aNumToProcess;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#getNumToProcess()
   */
  @Override
  public int getNumToProcess() {
    return (int) num2Process;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#setStartingEntityId(java.lang.String)
   */
  @Override
  public void setStartingEntityId(String aStartAt) {
    startAt = aStartAt;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#getStartingEntityId()
   */
  @Override
  public String getStartingEntityId() {
    return startAt;
  }

  /*
   * (non-Javadoc)
   *
   * @see
   * org.apache.uima.collection.metadata.CpeConfiguration#setCheckpoint(org.apache.uima.collection.
   * metadata.CpeCheckpoint)
   */
  @Override
  public void setCheckpoint(CpeCheckpoint aCheckpoint) throws CpeDescriptorException {
    checkpoint = aCheckpoint;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#getCheckpoint()
   */
  @Override
  public CpeCheckpoint getCheckpoint() {
    return checkpoint;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#removeCheckpoint()
   */
  @Override
  public void removeCheckpoint() {
    checkpoint = null;
  }

  /*
   * (non-Javadoc)
   *
   * @see
   * org.apache.uima.collection.metadata.CpeConfiguration#setCpeTimer(org.apache.uima.collection.
   * metadata.CpeTimer)
   */
  @Override
  public void setCpeTimer(CpeTimer aTimer) {
    timerImpl = aTimer.get();
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#getCpeTimer()
   */
  @Override
  public CpeTimer getCpeTimer() {
    return new CpeTimerImpl(timerImpl);
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#removeCpeTimer()
   */
  @Override
  public void removeCpeTimer() {
    timerImpl = "";
  }

  /**
   * Gets the deploy as.
   *
   * @return the deploy as
   */
  public String getDeployAs() {
    return deployAs;
  }

  /**
   * Gets the num 2 process.
   *
   * @return the num 2 process
   */
  public long getNum2Process() {
    return num2Process;
  }

  /**
   * Gets the start at.
   *
   * @return the start at
   */
  public String getStartAt() {
    return startAt;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#getTimerImpl()
   */
  @Override
  public String getTimerImpl() {
    return timerImpl;
  }

  /**
   * Sets the deploy as.
   *
   * @param string
   *          the new deploy as
   */
  public void setDeployAs(String string) {
    deployAs = string;
  }

  /**
   * Sets the num to process.
   *
   * @param l
   *          the new num to process
   */
  public void setNumToProcess(long l) {
    num2Process = l;
  }

  /**
   * Sets the start at.
   *
   * @param aStartAt
   *          the new start at
   */
  public void setStartAt(String aStartAt) {

    startAt = aStartAt;
  }

  /**
   * Sets the timer impl.
   *
   * @param string
   *          the new timer impl
   */
  public void setTimerImpl(String string) {
    timerImpl = string;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#getOutputQueue()
   */
  @Override
  public OutputQueue getOutputQueue() {
    return outputQueue;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.collection.metadata.CpeConfiguration#getMaxTimeToWait()
   */
  @Override
  public int getMaxTimeToWait() {
    if (getOutputQueue() == null) {
      return 0;
    }
    return getOutputQueue().getDequeueTimeout();
  }

  /**
   * Sets the output queue.
   *
   * @param queue
   *          the new output queue
   */
  public void setOutputQueue(OutputQueue queue) {
    outputQueue = queue;
  }

  /*
   * (non-Javadoc)
   *
   * @see org.apache.uima.resource.metadata.impl.MetaDataObject_impl#getXmlizationInfo()
   */
  @Override
  protected XmlizationInfo getXmlizationInfo() {
    return XMLIZATION_INFO;
  }

  /** The Constant XMLIZATION_INFO. */
  static final private XmlizationInfo XMLIZATION_INFO = new XmlizationInfo("cpeConfig",
          new PropertyXmlInfo[] { new PropertyXmlInfo("numToProcess"),
              new PropertyXmlInfo("deployAs"), new PropertyXmlInfo("checkpoint", null),
              new PropertyXmlInfo("timerImpl"), new PropertyXmlInfo("outputQueue", null),
              new PropertyXmlInfo("startAt"), });

}


text:
<RETS ReplyCode="0" ReplyText="Operation Success.">
<RETS-RESPONSE>
MemberName=
User=Username,NULL,NULL,Username
Broker=
MetadataVersion=1.11.75995
MetadataTimestamp=2016-11-17T17:24:24Z
MinMetadataTimestamp=2016-11-17T17:24:24Z
Login=http://server.rets.com/rets/Login_with_Action.ashx
Action=http://server.rets.com/rets/Action.ashx
Logout=http://server.rets.com/rets/Logout.ashx
Search=http://server.rets.com/rets/Search.ashx
GetMetadata=http://server.rets.com/rets/GetMetadata.ashx
GetObject=http://server.rets.com/rets/GetObject.ashx
Update=http://server.rets.com/rets/Update.ashx
PostObject=http://server.rets.com/rets/PostObject.ashx
</RETS-RESPONSE>
</RETS>

redpajama_set_name: RedPajamaGithub


text:
module ChefWorkflow
  module Testlib
    VERSION = "0.2.0"
  end
end


text:
<!DOCTYPE html>

    <meta charset="UTF-8">
    <title>Список задач. Javascript & JSON.</title>
    <link rel="stylesheet" href="css/normalize.css"/>
    <link rel="stylesheet" href="css/todo.css"/>
    <link rel="stylesheet" href="../../resources/css/fonts.css"/>
    <link rel="stylesheet" href="css/responsive.css"/>

Список задач

Демонстрационное приложение. Javascript & JSON.

                                    <input id="todoText" type="text" class="todo-input" placeholder="Какие планы ?">
                                    <button id="addButton" type="button" class="todo-button">Добавить</button>

Всего: 0 задач

                Exadel, 2016

        <input class="item-check" type="checkbox">описание задачи


text:
var app=angular.module("Ce",["ngRoute"]);
app.config(function($routeProvider){
	$routeProvider
	.when("/",{
		templateUrl : "app/view/ma/main.html",
		controller : "home"
	})
	.when("/Report",{
		templateUrl : "app/view/bo/main.html",
		controller : "home"
	})
	.otherwise({
        template : "
Nada

Ejemplo de pagina no encotrada,
"
    });
});


text:
""" 'help' command.
"""
# Copyright ©  2015 1&1 Group <btw-users@googlegroups.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import, unicode_literals, print_function

import os

import click

from .. import config
from ..util.dclick import pretty_path

@config.cli.command(name='help')
@click.pass_context
def help_command(ctx):
    """Print some information on the system environment."""
    def banner(title):
        "Helper"
        click.echo('')
        click.secho('~~~ {} ~~~'.format(title), fg='green', bg='black', bold=True)

    app_name = ctx.find_root().info_name
    click.secho('*** "{}" Help & Information ***'.format(app_name), fg='white', bg='blue', bold=True)

    banner('Version Information')
    click.echo(config.version_info(ctx))

    banner('Configuration')
    locations = config.locations(exists=False, extras=ctx.find_root().params.get('config', None))
    locations = [(u'✔' if os.path.exists(i) else u'✘', pretty_path(i)) for i in locations]
    click.echo(u'The following configuration files are merged in order, if they exist:\n    {0}'.format(
        u'\n    '.join(u'{}   {}'.format(*i) for i in locations),
    ))

    banner('More Help')
    click.echo("Call '{} --help' to get a list of available commands & options.".format(app_name))
    click.echo("Call '{} «command» --help' to get help on a specific command.".format(app_name))
    click.echo("Call '{} --version' to get the above version information separately.".format(app_name))
    click.echo("Call '{} --license' to get licensing informatioon.".format(app_name))

    # click.echo('\ncontext = {}'.format(repr(vars(ctx))))
    # click.echo('\nparent = {}'.format(repr(vars(ctx.parent))))


text:
#include "tensorflow/core/kernels/reduction_ops_common.h"

namespace tensorflow {

#define REGISTER_CPU_KERNELS(type)                                          \
  REGISTER_KERNEL_BUILDER(                                                  \
      Name("Max")                                                           \
          .Device(DEVICE_CPU)                                               \
          .TypeConstraint<type>("T")                                        \
          .TypeConstraint<int32>("Tidx"),                                   \
      ReductionOp<CPUDevice, type, int32,                                   \
                  Eigen::internal::MaxReducer<type, Eigen::PropagateNaN>>); \
  REGISTER_KERNEL_BUILDER(                                                  \
      Name("Max")                                                           \
          .Device(DEVICE_CPU)                                               \
          .TypeConstraint<type>("T")                                        \
          .TypeConstraint<int64_t>("Tidx"),                                 \
      ReductionOp<CPUDevice, type, int64,                                   \
                  Eigen::internal::MaxReducer<type, Eigen::PropagateNaN>>);
TF_CALL_REAL_NUMBER_TYPES(REGISTER_CPU_KERNELS);
#undef REGISTER_CPU_KERNELS

#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM

#define REGISTER_GPU_KERNELS(type)                                          \
  REGISTER_KERNEL_BUILDER(                                                  \
      Name("Max")                                                           \
          .Device(DEVICE_GPU)                                               \
          .TypeConstraint<type>("T")                                        \
          .TypeConstraint<int32>("Tidx")                                    \
          .HostMemory("reduction_indices"),                                 \
      ReductionOp<GPUDevice, type, int32,                                   \
                  Eigen::internal::MaxReducer<type, Eigen::PropagateNaN>>); \
  REGISTER_KERNEL_BUILDER(                                                  \
      Name("Max")                                                           \
          .Device(DEVICE_GPU)                                               \
          .TypeConstraint<type>("T")                                        \
          .TypeConstraint<int64_t>("Tidx")                                  \
          .HostMemory("reduction_indices"),                                 \
      ReductionOp<GPUDevice, type, int64,                                   \
                  Eigen::internal::MaxReducer<type, Eigen::PropagateNaN>>);

REGISTER_GPU_KERNELS(Eigen::half);
REGISTER_GPU_KERNELS(float);
REGISTER_GPU_KERNELS(double);
REGISTER_GPU_KERNELS(int64_t);

#undef REGISTER_GPU_KERNELS
#endif

// A special DEVICE_DEFAULT kernel for int32.
// TODO(b/25387198): Also enable int32 in device memory. This kernel
// registration requires all int32 inputs and outputs to be in host memory.
REGISTER_KERNEL_BUILDER(
    Name("Max")
        .Device(DEVICE_DEFAULT)
        .HostMemory("reduction_indices")
        .HostMemory("input")
        .HostMemory("output")
        .TypeConstraint<int32>("T")
        .TypeConstraint<int32>("Tidx"),
    ReductionOp<CPUDevice, int32, int32, Eigen::internal::MaxReducer<int32>>);
REGISTER_KERNEL_BUILDER(
    Name("Max")
        .Device(DEVICE_DEFAULT)
        .HostMemory("reduction_indices")
        .HostMemory("input")
        .HostMemory("output")
        .TypeConstraint<int32>("T")
        .TypeConstraint<int64_t>("Tidx"),
    ReductionOp<CPUDevice, int32, int64, Eigen::internal::MaxReducer<int32>>);

}  // namespace tensorflow


text:
package com.intellij.openapi.vcs.roots;

import com.intellij.openapi.vcs.VcsRoot;
import com.intellij.openapi.vfs.VirtualFile;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.Collection;

/**
 * Interface for detecting VCS roots in the project.
 *
 * @author Nadya Zabrodina
 */
public interface VcsRootDetector {

  /**
   * Detect vcs roots for whole project
   */
  @NotNull
  Collection<VcsRoot> detect();

  /**
   * Detect vcs roots for startDir
   */
  @NotNull
  Collection<VcsRoot> detect(@Nullable VirtualFile startDir);
}


text:
layout: post
title: "FabFitFun Exclusive - Get a FREE ALOHA Superfood Smoothie Kit!"
description: "Value of $19.90"
headline: "FabFitFun Exclusive - Get a FREE ALOHA Superfood Smoothie Kit!"
category: Coupons
tags: [FabFitFun, Subscriptions, Coupons]
comments: true
mathjax: null
published: true
featured: false
type: photo
imagefeature: "FabFitFunAlohaFreeTrialMay2015.png"
date: 2015-05-11 10:50:39 -07:00
---

![FabFitFun Free Aloha Trial](/images/FabFitFunAlohaFreeTrialMay2015.png)

Cost: Pay only $4.79 for shipping and handling

Value: $19.90

Coupon: Click here to get your Free Trial

*Note: 7 days after receiving the free trial, you'll be enrolled in their monthly service, but you can cancel any time.

![FabFitFun Free Aloha Trial Details](/images/FabFitFunAlohaFreeTrialMay2015Details.jpg)


text:
package org.jboss.aerogear.unifiedpush.cassandra.dao.model;

import java.io.Serializable;
import java.util.UUID;

import org.springframework.data.cassandra.core.cql.PrimaryKeyType;
import org.springframework.data.cassandra.core.mapping.PrimaryKeyClass;
import org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn;

@PrimaryKeyClass
public class UserKey implements Serializable {
	private static final long serialVersionUID = -6419944724251681328L;
	public static final String FIELD_PUSH_APPLICATION_ID = "push_application_id";
	public static final String FIELD_USER_ID = "user_id";
	public static final String FIELD_ALIAS = "alias";

	@PrimaryKeyColumn(name = FIELD_PUSH_APPLICATION_ID, ordinal = 0, type = PrimaryKeyType.PARTITIONED)
	private UUID pushApplicationId;

	@PrimaryKeyColumn(name = FIELD_USER_ID, ordinal = 1, type = PrimaryKeyType.PARTITIONED)
	private UUID id;

	@PrimaryKeyColumn(name = FIELD_ALIAS, ordinal = 0, type = PrimaryKeyType.CLUSTERED)
	private String alias;

	public UserKey() {
	}

	public UserKey(UUID pushApplicationId, UUID id) {
		super();
		this.pushApplicationId = pushApplicationId;
		this.id = id;
	}

	public UserKey(UUID pushApplicationId, UUID id, String alias) {
		this(pushApplicationId, id);
		this.alias = alias;
	}

	public UUID getId() {
		return id;
	}

	public void setId(UUID id) {
		this.id = id;
	}

	public String getAlias() {
		return alias;
	}

	public void setAlias(String alias) {
		this.alias = alias;
	}

	public UUID getPushApplicationId() {
		return pushApplicationId;
	}

	public void setPushApplicationId(UUID pushApplicationId) {
		this.pushApplicationId = pushApplicationId;
	}

	@Override
	public String toString() {
        return getClass().getSimpleName()
            + "[alias=" + getAlias()
            + ", id=" + getId()
            + ", pushApplicationId=" + getPushApplicationId()
            + "]";
	}
}


text:
package com.google.common.primitives;

public final class Floats
{
  // Constructors

  private Floats(){
  }
  // Methods

  public static int hashCode(float arg1){
    return 0;
  }
  public static float min(float [] arg1){
    return 0.0f;
  }
  public static float max(float [] arg1){
    return 0.0f;
  }
  public static int indexOf(float [] arg1, float arg2){
    return 0;
  }
  public static int indexOf(float [] arg1, float [] arg2){
    return 0;
  }
  public static int compare(float arg1, float arg2){
    return 0;
  }
  public static float [] concat(float [] [] arg1){
    return (float []) null;
  }
  public static boolean contains(float [] arg1, float arg2){
    return false;
  }
  public static int lastIndexOf(float [] arg1, float arg2){
    return 0;
  }
  public static float [] toArray(java.util.Collection<java.lang.Float> arg1){
    return (float []) null;
  }
  public static java.lang.String join(java.lang.String arg1, float [] arg2){
    return (java.lang.String) null;
  }
  public static float [] ensureCapacity(float [] arg1, int arg2, int arg3){
    return (float []) null;
  }
  public static java.util.List<java.lang.Float> asList(float [] arg1){
    return (java.util.List) null;
  }
  public static java.util.Comparator<float []> lexicographicalComparator(){
    return (java.util.Comparator) null;
  }
}


text:
<?php
/**
 * CodeIgniter Log Library
 *
 * @category   Applications
 * @package    CodeIgniter
 * @subpackage Libraries
 * @author     Bo-Yi Wu <appleboy.tw@gmail.com>
 * @license    BSD License
 * @link       http://blog.wu-boy.com/
 * @since      Version 1.0
 */
defined('BASEPATH') OR exit('No direct script access allowed');

class Lib_log
{
    /**
     * ci
     *
     * @param instance object
     */
    private $_ci;

    /**
     * log table name
     *
     * @param string
     */
    private $_log_table_name;

    public $levels = array(
        E_ERROR             => 'Error',
        E_WARNING           => 'Warning',
        E_PARSE             => 'Parsing Error',
        E_NOTICE            => 'Notice',
        E_CORE_ERROR        => 'Core Error',
        E_CORE_WARNING      => 'Core Warning',
        E_COMPILE_ERROR     => 'Compile Error',
        E_COMPILE_WARNING   => 'Compile Warning',
        E_USER_ERROR        => 'User Error',
        E_USER_WARNING      => 'User Warning',
        E_USER_NOTICE       => 'User Notice',
        E_STRICT            => 'Runtime Notice',
        E_RECOVERABLE_ERROR => 'Catchable error',
        E_DEPRECATED        => 'Runtime Notice',
        E_USER_DEPRECATED   => 'User Warning'
    );

    /**
     * constructor
     *
     */
    public function __construct()
    {
        $this->_ci =& get_instance();
        set_error_handler(array($this, 'error_handler'));
        set_exception_handler(array($this, 'exception_handler'));
        // Load database driver
        $this->_ci->load->database();
        // Load config file
        $this->_ci->load->config('log');
        $this->_log_table_name = ($this->_ci->config->item('log_table_name')) ? $this->_ci->config->item('log_table_name') : 'logs';
    }

    /**
     * PHP Error Handler
     *
     * @param   int
     * @param   string
     * @param   string
     * @param   int
     * @return void
     */
    public function error_handler($severity, $message, $filepath, $line)
    {
        $data = array(
            'errno' => $severity,
            'errtype' => isset($this->levels[$severity]) ? $this->levels[$severity] : $severity,
            'errstr' => $message,
            'errfile' => $filepath,
            'errline' => $line,
            'user_agent' => $this->_ci->input->user_agent(),
            'ip_address' => $this->_ci->input->ip_address(),
            'time' => date('Y-m-d H:i:s')
        );

        $this->_ci->db->insert($this->_log_table_name, $data);
    }

    /**
     * PHP Error Handler
     *
     * @param   object
     * @return void
     */
    public function exception_handler($exception)
    {
        $data = array(
            'errno' => $exception->getCode(),
            'errtype' => isset($this->levels[$exception->getCode()]) ? $this->levels[$exception->getCode()] : $exception->getCode(),
            'errstr' => $exception->getMessage(),
            'errfile' => $exception->getFile(),
            'errline' => $exception->getLine(),
            'user_agent' => $this->_ci->input->user_agent(),
            'ip_address' => $this->_ci->input->ip_address(),
            'time' => date('Y-m-d H:i:s')
        );

        $this->_ci->db->insert($this->_log_table_name, $data);
    }
}

/* End of file Lib_log.php */


text:
package com.jagex;

public final class Class121 {

   NodeContainer aNodeContainer_1528 = new NodeContainer();

   public void method1616(NodeContainer var1) {
      if(var1.nextNodeContainer != null) {
         var1.unlinkContainer();
      }

      var1.nextNodeContainer = this.aNodeContainer_1528;
      var1.prevNodeContainer = this.aNodeContainer_1528.prevNodeContainer;
      var1.nextNodeContainer.prevNodeContainer = var1;
      var1.prevNodeContainer.nextNodeContainer = var1;
   }

   NodeContainer method1617() {
      NodeContainer var1 = this.aNodeContainer_1528.prevNodeContainer;
      if(var1 == this.aNodeContainer_1528) {
         return null;
      } else {
         var1.unlinkContainer();
         return var1;
      }
   }

   public NodeContainer method1618() {
      NodeContainer var1 = this.aNodeContainer_1528.prevNodeContainer;
      return var1 == this.aNodeContainer_1528 ?null:var1;
   }

   public void method1620(NodeContainer var1) {
      if(var1.nextNodeContainer != null) {
         var1.unlinkContainer();
      }

      var1.nextNodeContainer = this.aNodeContainer_1528.nextNodeContainer;
      var1.prevNodeContainer = this.aNodeContainer_1528;
      var1.nextNodeContainer.prevNodeContainer = var1;
      var1.prevNodeContainer.nextNodeContainer = var1;
   }

   void method1625() {
      while(true) {
         NodeContainer var1 = this.aNodeContainer_1528.prevNodeContainer;
         if(var1 == this.aNodeContainer_1528) {
            return;
         }

         var1.unlinkContainer();
      }
   }

   public Class121() {
      this.aNodeContainer_1528.prevNodeContainer = this.aNodeContainer_1528;
      this.aNodeContainer_1528.nextNodeContainer = this.aNodeContainer_1528;
   }
}


text:
(function (env) {
    'use strict';
    env.ddg_spice_stocks = function(api_result){

        if (!api_result || !api_result.length) {
            return Spice.failed('stocks');
        }

        var result = api_result[0];

        // url is path on their domain:
        result.url = 'http://ycharts.com' + result.url;

        // add title tag for link:
        result.urlTitle = 'View more ' + result.name + ' stock data at YCharts';

        // remove +/- from change attributes and add up/down class:
        if (result.change.charAt(0) === '+') {
            result.quoteChangeDir = 'up';
        } else if(result.change.charAt(0) === '-') {
            result.quoteChangeDir = 'down';
        } else {
            result.quoteChangeDir = 'same';
        }

        result.change = result.change.replace(/^[+|-]/,'');
        result.change_percent = result.change_percent.replace(/^[+|-]/,'');

        Spice.add({
            id: 'stocks',
            name: 'Stock',
            data: result,
            meta: {
                sourceName: 'YCharts',
                sourceUrl: result.url
            },
            templates: {
                group: 'base',
                options: {
                    content: Spice.stocks.content,
                    moreAt: true
                }
            }
        });
    };
}(this));


text:
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
import { CONST_EXPR } from 'angular2/src/facade/lang';
import { ListWrapper, StringMapWrapper } from 'angular2/src/facade/collection';
import { ObservableWrapper, EventEmitter } from 'angular2/src/facade/async';
import { Directive, forwardRef, Provider, Inject, Optional, Self } from 'angular2/core';
import { ControlContainer } from './control_container';
import { setUpControl, setUpControlGroup, composeValidators, composeAsyncValidators } from './shared';
import { Validators, NG_VALIDATORS, NG_ASYNC_VALIDATORS } from '../validators';
const formDirectiveProvider = CONST_EXPR(new Provider(ControlContainer, { useExisting: forwardRef(() => NgFormModel) }));
/**
 * Binds an existing control group to a DOM element.
 *
 * ### Example ([live demo](http://plnkr.co/edit/jqrVirudY8anJxTMUjTP?p=preview))
 *
 * In this example, we bind the control group to the form element, and we bind the login and
 * password controls to the login and password elements.
 *
 *  ```typescript
 * @Component({
 *   selector: 'my-app',
 *   template: `
 *     <div>
 *       <h2>NgFormModel Example</h2>
 *       <form [ngFormModel]="loginForm">
 *         <p>Login: <input type="text" ngControl="login"></p>
 *         <p>Password: <input type="password" ngControl="password"></p>
 *       </form>
 *       <p>Value:</p>
 *       <pre>{{value}}</pre>
 *     </div>
 *   `,
 *   directives: [FORM_DIRECTIVES]
 * })
 * export class App {
 *   loginForm: ControlGroup;
 *
 *   constructor() {
 *     this.loginForm = new ControlGroup({
 *       login: new Control(""),
 *       password: new Control("")
 *     });
 *   }
 *
 *   get value(): string {
 *     return JSON.stringify(this.loginForm.value, null, 2);
 *   }
 * }
 *  ```
 *
 * We can also use ngModel to bind a domain model to the form.
 *
 *  ```typescript
 * @Component({
 *      selector: "login-comp",
 *      directives: [FORM_DIRECTIVES],
 *      template: `
 *        <form [ngFormModel]='loginForm'>
 *          Login <input type='text' ngControl='login' [(ngModel)]='credentials.login'>
 *          Password <input type='password' ngControl='password'
 *                          [(ngModel)]='credentials.password'>
 *          <button (click)="onLogin()">Login</button>
 *        </form>`
 *      })
 * class LoginComp {
 *  credentials: {login: string, password: string};
 *  loginForm: ControlGroup;
 *
 *  constructor() {
 *    this.loginForm = new ControlGroup({
 *      login: new Control(""),
 *      password: new Control("")
 *    });
 *  }
 *
 *  onLogin(): void {
 *    // this.credentials.login === 'some login'
 *    // this.credentials.password === 'some password'
 *  }
 * }
 *  ```
 */
export let NgFormModel = class extends ControlContainer {
    constructor(_validators, _asyncValidators) {
        super();
        this._validators = _validators;
        this._asyncValidators = _asyncValidators;
        this.form = null;
        this.directives = [];
        this.ngSubmit = new EventEmitter();
    }
    ngOnChanges(changes) {
        if (StringMapWrapper.contains(changes, "form")) {
            var sync = composeValidators(this._validators);
            this.form.validator = Validators.compose([this.form.validator, sync]);
            var async = composeAsyncValidators(this._asyncValidators);
            this.form.asyncValidator = Validators.composeAsync([this.form.asyncValidator, async]);
            this.form.updateValueAndValidity({ onlySelf: true, emitEvent: false });
        }
        this._updateDomValue();
    }
    get formDirective() { return this; }
    get control() { return this.form; }
    get path() { return []; }
    addControl(dir) {
        var ctrl = this.form.find(dir.path);
        setUpControl(ctrl, dir);
        ctrl.updateValueAndValidity({ emitEvent: false });
        this.directives.push(dir);
    }
    getControl(dir) { return this.form.find(dir.path); }
    removeControl(dir) { ListWrapper.remove(this.directives, dir); }
    addControlGroup(dir) {
        var ctrl = this.form.find(dir.path);
        setUpControlGroup(ctrl, dir);
        ctrl.updateValueAndValidity({ emitEvent: false });
    }
    removeControlGroup(dir) { }
    getControlGroup(dir) {
        return this.form.find(dir.path);
    }
    updateModel(dir, value) {
        var ctrl = this.form.find(dir.path);
        ctrl.updateValue(value);
    }
    onSubmit() {
        ObservableWrapper.callEmit(this.ngSubmit, null);
        return false;
    }
    /** @internal */
    _updateDomValue() {
        this.directives.forEach(dir => {
            var ctrl = this.form.find(dir.path);
            dir.valueAccessor.writeValue(ctrl.value);
        });
    }
};
NgFormModel = __decorate([
    Directive({
        selector: '[ngFormModel]',
        bindings: [formDirectiveProvider],
        inputs: ['form: ngFormModel'],
        host: { '(submit)': 'onSubmit()' },
        outputs: ['ngSubmit'],
        exportAs: 'ngForm'
    }),
    __param(0, Optional()),
    __param(0, Self()),
    __param(0, Inject(NG_VALIDATORS)),
    __param(1, Optional()),
    __param(1, Self()),
    __param(1, Inject(NG_ASYNC_VALIDATORS)),
    __metadata('design:paramtypes', [Array, Array])
], NgFormModel);


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Beih. Nova Hedwigia 96: 181 (1989)

#### Original name
Tyromyces nemorosus Corner, 1989

### Remarks
null


text:
package com.intellij.lang.jsp;

import java.util.Set;

/**
 * @author ik
 */
public interface JspFileViewProvider extends JspxFileViewProvider {
  Set<String> getXmlNsPrefixes(CharSequence buffer);
}


text:
namespace e2 { namespace interface {

class i_rendergraphbuilder {
public:
    // virtual bool process( std::list< ::e2::interface::i_rendernode * > * nodes ) = 0;
    virtual bool link_prerequisite( ::e2::interface::i_rendernode * n, ::e2::interface::i_rendernode * n_prereq ) = 0;
    virtual bool set_handle( ::e2::interface::i_rendernode * node ) = 0;
};

} }

#endif


text:
require 'test_helper'

class StateTransitionTest < Test::Unit::TestCase
  context 'state transition' do
    setup do
      @opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
      @st = AASM::SupportingClasses::StateTransition.new(@opts)
    end

    should 'set from, to, and opts attr readers' do
      assert_equal @opts[:from], @st.from
      assert_equal @opts[:to], @st.to
      assert_equal @opts, @st.options
    end

    should 'pass equality check if from and to are the same' do
      obj = OpenStruct.new
      obj.from = @opts[:from]
      obj.to = @opts[:to]

      assert_equal @st, obj
    end

    should 'fail equality check if from is not the same' do
      obj = OpenStruct.new
      obj.from = 'blah'
      obj.to = @opts[:to]

      assert_not_equal @st, obj
    end

    should 'fail equality check if to is not the same' do
      obj = OpenStruct.new
      obj.from = @opts[:from]
      obj.to = 'blah'

      assert_not_equal @st, obj
    end

    context 'when performing guard checks' do
      should 'return true if there is no guard' do
        opts = {:from => 'foo', :to => 'bar'}
        st = AASM::SupportingClasses::StateTransition.new(opts)
        assert st.perform(nil)
      end

      should 'call the method on the object if guard is a symbol' do
        opts = {:from => 'foo', :to => 'bar', :guard => :test_guard}
        st = AASM::SupportingClasses::StateTransition.new(opts)

        mock(obj = Object.new).test_guard

        st.perform(obj)
      end

      should 'call the method on the object if guard is a string' do
        opts = {:from => 'foo', :to => 'bar', :guard => 'test_guard'}
        st = AASM::SupportingClasses::StateTransition.new(opts)

        mock(obj = Object.new).test_guard

        st.perform(obj)
      end

      should 'call the proc passing the object if guard is a proc' do
        opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test_guard}}
        st = AASM::SupportingClasses::StateTransition.new(opts)

        mock(obj = Object.new).test_guard

        st.perform(obj)
      end
    end
  end
end


text:
Both privacy and authenticity of the anonym will be hardened with a Transport Layer Security (TLS) to embargo broadcast Interprocess Communications (IPC). That is to say, to prevent the external network from seeing anything any more informative to snoops than a bit stream scrambled with high quality and short-lived credentials. The embargo affords an improved privacy and data integrity interval and also enables the TLS client authentication option.

Automation of TLS with forward secrecy (e.g., new certs each app session) and hotel juliet after each push to remote.

Always cycle the socket process after credential changes. A SIGHUP or service-restart may not fully & reliably refresh config used by open active sockets. It usually works, but can leave some things in the old state. The app is trained to verify and repair the TLS encryption hierarchy and socket configurations as it initializes it's own configuration, but that only happens at npm-start.

Hotel Juliet or overwrite all keys in the private communications keystore, including the "CA", is a modern version of a complete rekey not unlike what the Cold War cryptographers of the 20th century termed, "Hotel Juliet", "hj" or, coloquially as "going high and blind." Hotel Juliet rekeys ought to be undertaken regularly. The hj will generate a new self-signed CA, thereby invalidating all TLS certificates currently in use so it takes the liberty to delete those too. The hj is your friend if anything happens to corrupt the TLS or you suspect someone uninvited is listening to your data stream. By testing the hj routinely the process will be familiar. Minor issues that tend to arise as systems change can be more easily mitigated. Without testing, a total rekey will feel ever more threatening than it really is, in part due to the unfamiliarity, in part due to the trepidations induced by avoidance.

Use the __certificate__ CLI command to review the certificates on hand, to generate new certificates or to replace the credentials currently in use.

## CA

The app's private TLS encryption hierarchy is rooted by an app generated Certificate self-signed by the host. We will refer to this as the "CA" or Certificate Authority, even though it is not signed by a Public Authority. This is absolutely NOT a secure way to use TLS when serving data to the network. Self signing is highly vulnerable to man-in-the-middle styled penetration. Because our need is to embargo our data bits from the network, not to broadcast them securely, and our requirements include the ability to get all your work - other than source control push/pull to remote - done whether or not the host is connected to a network. In this usage, the self-signed root is the most appropriate root vector for app authentication. For increased security of our shroud, we will replace the complete hierarchy frequently and renew our socket creds at each app start.

The CA is generated when it is needed to sign a credential and not found. No explicit use action is required.

## Docker

At the next app start after __config.docker.TLS__ is set to true, the anonym will cloak the dockerd socket's API requests/responses under TLS using credentials signed by the host's self-signed 'CA' and assure that the correct configuration and credentials are in place at 'npm start'. This will instrument the Docker daemon with TLS server authentication.

The TLS credentials appropriate to the configuration must be present at daemon start in order for the Docker API to listen using TLS.
Docker docs warn, "Do not set options in daemon.json that have already been set as daemon startup command line args."

Review the daemons command line args with something like:
    > ps -eo command|grep dockerd
    /~clip~/usr/bin/dockerd __-H fd:// --containerd=/run/containerd/containerd.sock__
    -or-
    > sudo systemctl status docker
    bill@HOST:~/anonym$ sudo systemctl status docker
    ● docker.service - Docker Application Container Engine
      Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
      Active: active (running) since Sat 2020-02-15 07:25:40 MST; 5h 21min ago
        Docs: https://docs.docker.com
    Main PID: 1622 (dockerd)
        Tasks: 29
      CGroup: /system.slice/docker.service
              ├─1622 /usr/bin/dockerd __-H fd:// --containerd=/run/containerd/containerd.sock__
              ├─6161 /usr/bin/docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 46769 -container-ip 172.17.0.3 -container-port 1433
              └─8532 /usr/bin/docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 43527 -container-ip 172.17.0.2 -container-port 1433

To enable TLS (https) on the Docker Container Instance Engine daemon, a daemon.json object file is placed in the /etc/docker folder with, minimally, the following unique keys:

    {
        "tls": true,
        "tlscacert": "/~clip~/anonym/private/CA-cert.pem",
        "tlscert": "/~clip~/anonym/private/docker-cert.pem",
        "tlskey": "/~clip~/anonym/private/docker-key.pem"
    }

When __config.docker.api.tlsverify__ is set to true, Docker client authentication is enabled at the next CLI start.
Docker client authentication implies server authentiction and uses cientAuth credentials signed by the same Certificate as the server's key.
    From the CLI:
        certificate docker --clientAuth

File names for credentials not created by the anonym must follow the file naming convention expected
by the anonym - alternately, the local connectAPI function in the api.js module must be modified:
    for example, on my host, the CLI generates:
        "/~clip~/anonym/private/dockerCLI-cert.pem"
        "/~clip~/anonym/private/dockerCLI-key.pem"

[The rest of this section is a copy-paste snapshot from the Docker online documentation. See the current Docker documentation.]

The default location of the dockerd configuration file on Linux is /etc/docker/daemon.json.
The --config-file flag on the daemon startup command line can be used to specify a non-default config location.

This is an example of the allowed daemon.json options. I believe the values shown are the daemon defaults at the time of the snapshot. (11-6-2018): https://docs.docker.com/engine/reference/commandline/dockerd/#daemon-configuration-file

    {
        "authorization-plugins": [],
        "data-root": "",
        "dns": [],
        "dns-opts": [],
        "dns-search": [],
        "exec-opts": [],
        "exec-root": "",
        "experimental": false,
        "storage-driver": "",
        "storage-opts": [],
        "labels": [],
        "live-restore": true,
        "log-driver": "",
        "log-opts": {},
        "mtu": 0,
        "pidfile": "",
        "cluster-store": "",
        "cluster-store-opts": {},
        "cluster-advertise": "",
        "max-concurrent-downloads": 3,
        "max-concurrent-uploads": 5,
        "default-shm-size": "64M",
        "shutdown-timeout": 15,
        "debug": true,
        "hosts": [],
        "log-level": "",
        "tls": true,
        "tlsverify": true,
        "tlscacert": "",
        "tlscert": "",
        "tlskey": "",
        "swarm-default-advertise-addr": "",
        "api-cors-header": "",
        "selinux-enabled": false,
        "userns-remap": "",
        "group": "",
        "cgroup-parent": "",
        "default-ulimits": {},
        "init": false,
        "init-path": "/usr/libexec/docker-init",
        "ipv6": false,
        "iptables": false,
        "ip-forward": false,
        "ip-masq": false,
        "userland-proxy": false,
        "userland-proxy-path": "/usr/libexec/docker-proxy",
        "ip": "0.0.0.0",
        "bridge": "",
        "bip": "",
        "fixed-cidr": "",
        "fixed-cidr-v6": "",
        "default-gateway": "",
        "default-gateway-v6": "",
        "icc": false,
        "raw-logs": false,
        "allow-nondistributable-artifacts": [],
        "registry-mirrors": [],
        "seccomp-profile": "",
        "insecure-registries": [],
        "no-new-privileges": false,
        "default-runtime": "runc",
        "oom-score-adjust": -500,
        "node-generic-resources": ["NVIDIA-GPU=UUID1", "NVIDIA-GPU=UUID2"],
        "runtimes": {
            "cc-runtime": {
                "path": "/usr/bin/cc-runtime"
            },
            "custom": {
                "path": "/usr/local/bin/my-runc-replacement",
                "runtimeArgs": [
                    "--debug"
                    ]
            }
        }
    }
The command-line options, a quite similar listing, can be viewed at
  > dockerd --help
-or-
https://docs.docker.com/engine/reference/commandline/dockerd/
see also (https://docs.docker.com/engine/security/https/)

## SQLPad

When a connection to the anonym is needed from the outside world, a connection to the private __SQLPad__ is preferred where possible. The anonym's SQLPad is configured to run as a dependent child process and uses a private query store.

__SQLPad__ exposes basic authentication with secrets encrypted into it's nedb store in combination with TLS server authentication. Google authentication can also be configured for __SQLPad__'s oauth, and __SQLPad__ is tooled for SMTP for the old school network monkeys as well as Slack. If the sqlpad.json IP address is set to use a valid network address other than 'localhost' or perhaps the host's VNET gateway IP. In any case, SQLPad is a fine remote query tool. However, in keeping to the anonym theme, the CLI intentionally employs no remote dependencies into the query chain (e.g., no oauth, Slack, SMPT, Azure, etc.).

Nonetheless, it might be advantageous if other team members could jump on your anonym from time to time. __SQLPad__ would be the most straight-forward socket to use for that purpose. Unfortunately, __SQLPad__ does not use TLS client authentication. For that reason alone, __SQLPad__ remote access should only be enabed when needed and at least the basic passwords should always be used in addition to TLS.

__SQLPad__ can be configured in a _.json_ or _.ini_ file or in environment variables. __anonym__ uses use container environment variables. In the anonym the config implementation details for SQLPad and SQL Server containers are quite similar. Efforts to remove or decouple external resources from the run time environment is kept always at the fore.

See the SQLPad github repo for current configuration requirements when configuring for remote access. The SQLPad configuration has evolved considerable over 2019 and 2020 - with a couple of breaking changes in the mix. Some caution is advised.

SQLPad source https://github.com/rickbergfalk/sqlpad

## SQL Server

SQL Server has supported TLS of connections to the query engine for years.


text:
'use babel';

// eslint-disable-next-line import/no-extraneous-dependencies, import/extensions
import { CompositeDisposable } from 'atom';
import TreeView from './tree-view';
import TagGenerator from './tag-generator';
import TagParser from './tag-parser';

const SYMBOLS_NAVIGATOR = 'atom://symbols-navigator';
const SYMBOLS_NAVIGATOR_TITLE = 'Symbols';
const SYMBOLS_NAVIGATOR_ICON = 'list-unordered';

export default class SymbolsNavigatorView {
  constructor(statusBarManager) {
    this.statusBarManager = statusBarManager;

    this.element = document.createElement('div');
    this.element.classList.add('symbols-navigator', 'tool-panel', 'focusable-panel');
    this.element.tabIndex = -1;

    this.subscriptions = new CompositeDisposable();
    this.treeView = new TreeView(statusBarManager);
    this.element.appendChild(this.treeView.element);

    this.autoHideTypes = atom.config.get('symbols-navigator.autoHideTypes');
    this.sortByName = atom.config.get('symbols-navigator.sortBy') === 'Symbol Name';

    this.refreshTag = false;
    this.subscriptions.add(atom.config.onDidChange('symbols-navigator.sortBy', () => {
      this.sortByName = atom.config.get('symbols-navigator.sortBy') === 'Symbol Name';
      this.refreshTag = true;
    }));

    this.subscriptions.add(atom.config.onDidChange('symbols-navigator.autoHideTypes', () => {
      this.autoHideTypes = atom.config.get('symbols-navigator.autoHideTypes');
      this.refreshTag = true;
    }));

    this.subscriptions.add(atom.workspace.onDidChangeActivePaneItem(() => {
      this.removeEventForEditor();
      this.populate();
    }));

    this.subscriptions.add(atom.workspace.onDidOpen(() => {
      this.removeEventForEditor();
      this.populate();
    }));

    this.removeEventForEditor();
    this.populate();
    this.keyboardEvents();
  }

  getEditor() {
    return atom.workspace.getActiveTextEditor();
  }

  getScopeName() {
    if (
      atom.workspace.getActiveTextEditor() != null &&
      atom.workspace.getActiveTextEditor().getGrammar() != null
    ) {
      return atom.workspace.getActiveTextEditor().getGrammar().scopeName;
    }

    return undefined;
  }

  populate() {
    const editor = this.getEditor();
    this.statusBarManager.setEmptySymbolLabel();

    if (editor != null) {
      let filePath = editor.getPath();
      if (filePath !== this.previousFilePath || this.refreshTag) {
        this.generateTags(filePath);
        this.refreshTag = false;
        this.currentTag = null;
      }

      this.previousFilePath = filePath;

      this.onEditorSave = editor.onDidSave((event) => {
        filePath = event.path;
        this.generateTags(filePath);
      });

      this.statusBarManager.update(this.currentTag);

      this.onChangeRow = editor.onDidChangeCursorPosition(
        ({ oldBufferPosition, newBufferPosition }) => {
          if (oldBufferPosition.row !== newBufferPosition.row) {
            this.focusCurrentCursorTag();
          } else {
            this.statusBarManager.update(this.currentTag);
          }
        },
      );
    } else {
      this.previousFilePath = '';
      this.treeView.setEmptyRoot();
    }
  }

  focusCurrentCursorTag() {
    let editor;
    if ((editor = this.getEditor()) && (this.parser != null)) {
      const { row } = editor.getCursorBufferPosition();
      const tag = this.parser.getNearestTag(row);
      const currentScrollTop = this.element.scrollTop;
      const currentScrollBottom = this.element.scrollTop + this.element.offsetHeight;
      const changeScroll = this.treeView.select(tag, currentScrollTop, currentScrollBottom);
      if (changeScroll != null) {
        this.element.scrollTop = changeScroll;
      }
      this.currentTag = tag;
      this.statusBarManager.update(tag);
    }
  }

  generateTags(filePath) {
    new TagGenerator(filePath, this.getScopeName()).generate().then((tags) => {
      this.parser = new TagParser(tags, this.getScopeName());
      const { root, types } = this.parser.parse();
      this.treeView.setRoot(root, this.sortByName);

      if (this.autoHideTypes) {
        const hiddenTypes = this.autoHideTypes.split(' ');
        for (const type of types) {
          if (hiddenTypes.indexOf(type) !== -1) {
            this.treeView.toggleTypeVisible(type);
          }
        }
      }

      this.focusCurrentCursorTag();
    });
  }

  serialize() {}

  destroy() {
    this.removeEventForEditor();
    this.subscriptions.dispose();
    this.element.remove();
  }

  removeEventForEditor() {
    if (this.onEditorSave != null) {
      this.onEditorSave.dispose();
    }

    if (this.onChangeRow != null) {
      this.onChangeRow.dispose();
    }
  }

  unfocus() {
    atom.workspace.getCenter().activate();
  }

  hasFocus() {
    return document.activeElement === this.element;
  }

  toggleFocus() {
    if (this.hasFocus()) {
      this.unfocus();
    } else {
      this.show();
      this.element.focus();
    }
  }

  toggle() {
    atom.workspace.toggle(this);
  }

  hide() {
    atom.workspace.hide(this);
  }

  show() {
    atom.workspace.open(this, {
      searchAllPanes: true,
      activatePane: false,
      activateItem: false,
    }).then(() => {
      atom.workspace.paneContainerForURI(this.getURI()).show();
    });
  }

  keyboardEvents() {
    atom.commands.add(this.element, {
      'core:move-up': () => { this.treeView.moveUp(); },
      'core:move-down': () => { this.treeView.moveDown(); },
      'core:move-left': () => { this.treeView.moveLeft(); },
      'core:move-right': () => { this.treeView.moveRight(); },
      'core:move-to-top': () => { this.moveToTop(); },
      'core:move-to-bottom': () => { this.moveToBottom(); },
      'core:page-up': () => { this.pageUp(); },
      'core:page-down': () => { this.pageDown(); },
      'symbols-navigator:move-to-selected-symbol': () => { this.treeView.moveToSelectedSymbol(); },
    });
  }

  moveToTop() {
    this.element.scrollTop = 0;
  }

  moveToBottom() {
    this.element.scrollTop = this.element.scrollHeight;
  }

  pageUp() {
    this.element.scrollTop -= this.element.offsetHeight;
  }

  pageDown() {
    this.element.scrollTop += this.element.offsetHeight;
  }

  getURI() {
    return SYMBOLS_NAVIGATOR;
  }

  getTitle() {
    return SYMBOLS_NAVIGATOR_TITLE;
  }

  getIconName() {
    return SYMBOLS_NAVIGATOR_ICON;
  }

  getDefaultLocation() {
    return atom.config.get('symbols-navigator.position').toLowerCase();
  }

  getAllowedLocations() {
    return ['left', 'right'];
  }

  isPermanentDockItem() {
    return !atom.config.get('symbols-navigator.closeable');
  }
}


text:
package Google::Ads::GoogleAds::V11::Resources::PerformanceMaxUpgrade;

use strict;
use warnings;
use base qw(Google::Ads::GoogleAds::BaseEntity);

use Google::Ads::GoogleAds::Utils::GoogleAdsHelper;

sub new {
  my ($class, $args) = @_;
  my $self = {
    performanceMaxCampaign => $args->{performanceMaxCampaign},
    preUpgradeCampaign     => $args->{preUpgradeCampaign},
    status                 => $args->{status}};

  # Delete the unassigned fields in this object for a more concise JSON payload
  remove_unassigned_fields($self, $args);

  bless $self, $class;
  return $self;
}

1;


text: export {default} from './RichTextArea';


text:
package com.sonymobile.gitlab.exceptions;

/**
 * An exception indicating that authentication against the API failed.
 *
 * @author Emil Nilsson
 */
public class AuthenticationFailedException extends GitLabApiException {
    /**
     * Creates an authentication failure exception with a message.
     *
     * @param message the reason for the exception
     */
    public AuthenticationFailedException(String message) {
        super(message);
    }

    /**
     * Creates an authentication failure exception with a message and cause.
     *
     * @param message the reason for the exception
     * @param cause   the exception causing the authentication failure exception
     */
    public AuthenticationFailedException(String message, Throwable cause) {
        super(message, cause);
    }
}


text:
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.ApplicationModel.Activation;
using SDKTemplate.Common;

namespace SDKTemplate
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        public static MainPage Current;

        private FileActivatedEventArgs _fileEventArgs = null;
        public FileActivatedEventArgs FileEvent
        {
            get { return _fileEventArgs; }
            set { _fileEventArgs = value; }
        }

        private ProtocolActivatedEventArgs _protocolEventArgs = null;
        public ProtocolActivatedEventArgs ProtocolEvent
        {
            get { return _protocolEventArgs; }
            set { _protocolEventArgs = value; }
        }

        public void NavigateToFilePage()
        {
            ScenarioFrame.Navigate(this.Scenarios[2].ClassType);
        }

        public void NavigateToProtocolPage()
        {
            ScenarioFrame.Navigate(this.Scenarios[3].ClassType);
        }

        public MainPage()
        {
            this.InitializeComponent();

            // This is a static public property that allows downstream pages to get a handle to the MainPage instance
            // in order to call methods that are in this class.
            Current = this;

            Windows.Phone.UI.Input.HardwareButtons.BackPressed += HardwareButtons_BackPressed;
        }

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.  The Parameter
        /// property is typically used to configure the page.</param>
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            SuspensionManager.RegisterFrame(ScenarioFrame, "scenarioFrame");
            if (ScenarioFrame.Content == null)
            {
                // When the navigation stack isn't restored navigate to the ScenarioList
                if (!ScenarioFrame.Navigate(typeof(ScenarioList)))
                {
                    throw new Exception("Failed to create scenario list");
                }
            }
        }

        void HardwareButtons_BackPressed(object sender, Windows.Phone.UI.Input.BackPressedEventArgs e)
        {
            if (ScenarioFrame.CanGoBack)
            {
                // Clear the status block when navigating
                NotifyUser(String.Empty, NotifyType.StatusMessage);

                ScenarioFrame.GoBack();

                //Indicate the back button press is handled so the app does not exit
                e.Handled = true;
            }
        }

        public List<Scenario> Scenarios
        {
            get { return this.scenarios; }
        }

        /// <summary>
        /// Used to display messages to the user
        /// </summary>
        /// <param name="strMessage"></param>
        /// <param name="type"></param>
        public void NotifyUser(string strMessage, NotifyType type)
        {
            if (StatusBlock != null)
            {
                switch (type)
                {
                    case NotifyType.StatusMessage:
                        StatusBorder.Background = new SolidColorBrush(Windows.UI.Colors.Green);
                        break;
                    case NotifyType.ErrorMessage:
                        StatusBorder.Background = new SolidColorBrush(Windows.UI.Colors.Red);
                        break;
                }
                StatusBlock.Text = strMessage;

                // Collapse the StatusBlock if it has no text to conserve real estate.
                if (StatusBlock.Text != String.Empty)
                {
                    StatusBorder.Visibility = Windows.UI.Xaml.Visibility.Visible;
                }
                else
                {
                    StatusBorder.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
                }
            }
        }
    }

    public enum NotifyType
    {
        StatusMessage,
        ErrorMessage
    };

}


text:
<?php

namespace Gram\DataMapper;

interface IShardStrategy
{
    function getTableName($args);
}


text:
#ifndef __MONO_ERROR_H__
#define __MONO_ERROR_H__

#include <mono/utils/mono-publib.h>

enum {
	/*
	The supplied strings were dup'd by means of calling mono_error_dup_strings.
	*/
	MONO_ERROR_FREE_STRINGS = 0x0001,

	/*
	Something happened while processing the error and the resulting message is incomplete.
	*/
	MONO_ERROR_INCOMPLETE = 0x0002
};

enum {
	MONO_ERROR_NONE = 0,
	MONO_ERROR_MISSING_METHOD = 1,
	MONO_ERROR_MISSING_FIELD = 2,
	MONO_ERROR_TYPE_LOAD = 3,
	MONO_ERROR_FILE_NOT_FOUND = 4,
	MONO_ERROR_BAD_IMAGE = 5,
	MONO_ERROR_OUT_OF_MEMORY = 6,
	MONO_ERROR_ARGUMENT = 7,
	MONO_ERROR_NOT_VERIFIABLE = 8,
	/*
	 * This is a generic error mechanism is you need to raise an arbitrary corlib exception.
	 * You must pass the exception name otherwise prepare_exception will fail with internal execution.
	 */
	MONO_ERROR_GENERIC = 9
};

/*Keep in sync with MonoErrorInternal*/
typedef struct {
	unsigned short error_code;
    unsigned short hidden_0; /*DON'T TOUCH */

	void *hidden_1 [12]; /*DON'T TOUCH */
    char hidden_2 [128]; /*DON'T TOUCH */
} MonoError;

MONO_BEGIN_DECLS

MONO_API void
mono_error_init (MonoError *error);

MONO_API void
mono_error_init_flags (MonoError *error, unsigned short flags);

MONO_API void
mono_error_cleanup (MonoError *error);

MONO_API mono_bool
mono_error_ok (MonoError *error);

MONO_API unsigned short
mono_error_get_error_code (MonoError *error);

MONO_API const char*
mono_error_get_message (MonoError *error);

MONO_END_DECLS

#endif


text:
package org.apache.druid.server.coordinator;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import org.apache.druid.common.config.JacksonConfigManager;
import org.apache.druid.java.util.common.IAE;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import java.util.Collection;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * This class is for users to change their configurations while their Druid cluster is running.
 * These configurations are designed to allow only simple values rather than complicated JSON objects.
 *
 * @see JacksonConfigManager
 * @see org.apache.druid.common.config.ConfigManager
 */
public class CoordinatorDynamicConfig
{
  public static final String CONFIG_KEY = "coordinator.config";

  private final long leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments;
  private final long mergeBytesLimit;
  private final int mergeSegmentsLimit;
  private final int maxSegmentsToMove;
  private final int replicantLifetime;
  private final int replicationThrottleLimit;
  private final int balancerComputeThreads;
  private final boolean emitBalancingStats;

  /**
   * If true, {@link org.apache.druid.server.coordinator.helper.DruidCoordinatorSegmentKiller} sends kill tasks for
   * unused segments in all data sources.
   */
  private final boolean killUnusedSegmentsInAllDataSources;

  /**
   * List of specific data sources for which kill tasks are sent in {@link
   * org.apache.druid.server.coordinator.helper.DruidCoordinatorSegmentKiller}.
   */
  private final Set<String> specificDataSourcesToKillUnusedSegmentsIn;
  private final Set<String> decommissioningNodes;
  private final int decommissioningMaxPercentOfMaxSegmentsToMove;

  /**
   * Stale pending segments belonging to the data sources in this list are not killed by {@link
   * DruidCoordinatorCleanupPendingSegments}. In other words, segments in these data sources are "protected".
   *
   * Pending segments are considered "stale" when their created_time is older than {@link
   * DruidCoordinatorCleanupPendingSegments#KEEP_PENDING_SEGMENTS_OFFSET} from now.
   */
  private final Set<String> dataSourcesToNotKillStalePendingSegmentsIn;

  /**
   * The maximum number of segments that could be queued for loading to any given server.
   * Default values is 0 with the meaning of "unbounded" (any number of
   * segments could be added to the loading queue for any server).
   * See {@link LoadQueuePeon}, {@link org.apache.druid.server.coordinator.rules.LoadRule#run}
   */
  private final int maxSegmentsInNodeLoadingQueue;

  @JsonCreator
  public CoordinatorDynamicConfig(
      // Keeping the legacy 'millisToWaitBeforeDeleting' property name for backward compatibility. When the project is
      // updated to Jackson 2.9 it could be changed, see https://github.com/apache/incubator-druid/issues/7152
      @JsonProperty("millisToWaitBeforeDeleting")
          long leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments,
      @JsonProperty("mergeBytesLimit") long mergeBytesLimit,
      @JsonProperty("mergeSegmentsLimit") int mergeSegmentsLimit,
      @JsonProperty("maxSegmentsToMove") int maxSegmentsToMove,
      @JsonProperty("replicantLifetime") int replicantLifetime,
      @JsonProperty("replicationThrottleLimit") int replicationThrottleLimit,
      @JsonProperty("balancerComputeThreads") int balancerComputeThreads,
      @JsonProperty("emitBalancingStats") boolean emitBalancingStats,
      // Type is Object here so that we can support both string and list as Coordinator console can not send array of
      // strings in the update request. See https://github.com/apache/incubator-druid/issues/3055.
      // Keeping the legacy 'killDataSourceWhitelist' property name for backward compatibility. When the project is
      // updated to Jackson 2.9 it could be changed, see https://github.com/apache/incubator-druid/issues/7152
      @JsonProperty("killDataSourceWhitelist") Object specificDataSourcesToKillUnusedSegmentsIn,
      // Keeping the legacy 'killAllDataSources' property name for backward compatibility. When the project is
      // updated to Jackson 2.9 it could be changed, see https://github.com/apache/incubator-druid/issues/7152
      @JsonProperty("killAllDataSources") boolean killUnusedSegmentsInAllDataSources,
      // Type is Object here so that we can support both string and list as Coordinator console can not send array of
      // strings in the update request, as well as for specificDataSourcesToKillUnusedSegmentsIn.
      // Keeping the legacy 'killPendingSegmentsSkipList' property name for backward compatibility. When the project is
      // updated to Jackson 2.9 it could be changed, see https://github.com/apache/incubator-druid/issues/7152
      @JsonProperty("killPendingSegmentsSkipList") Object dataSourcesToNotKillStalePendingSegmentsIn,
      @JsonProperty("maxSegmentsInNodeLoadingQueue") int maxSegmentsInNodeLoadingQueue,
      @JsonProperty("decommissioningNodes") Object decommissioningNodes,
      @JsonProperty("decommissioningMaxPercentOfMaxSegmentsToMove") int decommissioningMaxPercentOfMaxSegmentsToMove
  )
  {
    this.leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments =
        leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments;
    this.mergeBytesLimit = mergeBytesLimit;
    this.mergeSegmentsLimit = mergeSegmentsLimit;
    this.maxSegmentsToMove = maxSegmentsToMove;
    this.replicantLifetime = replicantLifetime;
    this.replicationThrottleLimit = replicationThrottleLimit;
    this.balancerComputeThreads = Math.max(balancerComputeThreads, 1);
    this.emitBalancingStats = emitBalancingStats;
    this.killUnusedSegmentsInAllDataSources = killUnusedSegmentsInAllDataSources;
    this.specificDataSourcesToKillUnusedSegmentsIn = parseJsonStringOrArray(specificDataSourcesToKillUnusedSegmentsIn);
    this.dataSourcesToNotKillStalePendingSegmentsIn =
        parseJsonStringOrArray(dataSourcesToNotKillStalePendingSegmentsIn);
    this.maxSegmentsInNodeLoadingQueue = maxSegmentsInNodeLoadingQueue;
    this.decommissioningNodes = parseJsonStringOrArray(decommissioningNodes);
    Preconditions.checkArgument(
        decommissioningMaxPercentOfMaxSegmentsToMove >= 0 && decommissioningMaxPercentOfMaxSegmentsToMove <= 100,
        "decommissioningMaxPercentOfMaxSegmentsToMove should be in range [0, 100]"
    );
    this.decommissioningMaxPercentOfMaxSegmentsToMove = decommissioningMaxPercentOfMaxSegmentsToMove;

    if (this.killUnusedSegmentsInAllDataSources && !this.specificDataSourcesToKillUnusedSegmentsIn.isEmpty()) {
      throw new IAE(
          "can't have killUnusedSegmentsInAllDataSources and non-empty specificDataSourcesToKillUnusedSegmentsIn"
      );
    }
  }

  private static Set<String> parseJsonStringOrArray(Object jsonStringOrArray)
  {
    if (jsonStringOrArray instanceof String) {
      String[] list = ((String) jsonStringOrArray).split(",");
      Set<String> result = new HashSet<>();
      for (String item : list) {
        String trimmed = item.trim();
        if (!trimmed.isEmpty()) {
          result.add(trimmed);
        }
      }
      return result;
    } else if (jsonStringOrArray instanceof Collection) {
      return ImmutableSet.copyOf(((Collection) jsonStringOrArray));
    } else {
      return ImmutableSet.of();
    }
  }

  public static AtomicReference<CoordinatorDynamicConfig> watch(final JacksonConfigManager configManager)
  {
    return configManager.watch(
        CoordinatorDynamicConfig.CONFIG_KEY,
        CoordinatorDynamicConfig.class,
        CoordinatorDynamicConfig.builder().build()
    );
  }

  @Nonnull
  public static CoordinatorDynamicConfig current(final JacksonConfigManager configManager)
  {
    return Preconditions.checkNotNull(watch(configManager).get(), "Got null config from watcher?!");
  }

  @JsonProperty("millisToWaitBeforeDeleting")
  public long getLeadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments()
  {
    return leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments;
  }

  @JsonProperty
  public long getMergeBytesLimit()
  {
    return mergeBytesLimit;
  }

  @JsonProperty
  public boolean emitBalancingStats()
  {
    return emitBalancingStats;
  }

  @JsonProperty
  public int getMergeSegmentsLimit()
  {
    return mergeSegmentsLimit;
  }

  @JsonProperty
  public int getMaxSegmentsToMove()
  {
    return maxSegmentsToMove;
  }

  @JsonProperty
  public int getReplicantLifetime()
  {
    return replicantLifetime;
  }

  @JsonProperty
  public int getReplicationThrottleLimit()
  {
    return replicationThrottleLimit;
  }

  @JsonProperty
  public int getBalancerComputeThreads()
  {
    return balancerComputeThreads;
  }

  @JsonProperty("killDataSourceWhitelist")
  public Set<String> getSpecificDataSourcesToKillUnusedSegmentsIn()
  {
    return specificDataSourcesToKillUnusedSegmentsIn;
  }

  @JsonProperty("killAllDataSources")
  public boolean isKillUnusedSegmentsInAllDataSources()
  {
    return killUnusedSegmentsInAllDataSources;
  }

  @JsonProperty("killPendingSegmentsSkipList")
  public Set<String> getDataSourcesToNotKillStalePendingSegmentsIn()
  {
    return dataSourcesToNotKillStalePendingSegmentsIn;
  }

  @JsonProperty
  public int getMaxSegmentsInNodeLoadingQueue()
  {
    return maxSegmentsInNodeLoadingQueue;
  }

  /**
   * List of historical servers to 'decommission'. Coordinator will not assign new segments to 'decommissioning'
   * servers, and segments will be moved away from them to be placed on non-decommissioning servers at the maximum rate
   * specified by {@link CoordinatorDynamicConfig#getDecommissioningMaxPercentOfMaxSegmentsToMove}.
   *
   * @return list of host:port entries
   */
  @JsonProperty
  public Set<String> getDecommissioningNodes()
  {
    return decommissioningNodes;

  }

  /**
   * The percent of {@link CoordinatorDynamicConfig#getMaxSegmentsToMove()} that determines the maximum number of
   * segments that may be moved away from 'decommissioning' servers (specified by
   * {@link CoordinatorDynamicConfig#getDecommissioningNodes()}) to non-decommissioning servers during one Coordinator
   * balancer run. If this value is 0, segments will neither be moved from or to 'decommissioning' servers, effectively
   * putting them in a sort of "maintenance" mode that will not participate in balancing or assignment by load rules.
   * Decommissioning can also become stalled if there are no available active servers to place the segments. By
   * adjusting this value, an operator can prevent active servers from overload by prioritizing balancing, or
   * decrease decommissioning time instead.
   *
   * @return number in range [0, 100]
   */
  @Min(0)
  @Max(100)
  @JsonProperty
  public int getDecommissioningMaxPercentOfMaxSegmentsToMove()
  {
    return decommissioningMaxPercentOfMaxSegmentsToMove;
  }

  @Override
  public String toString()
  {
    return "CoordinatorDynamicConfig{" +
           "leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments="
           + leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments +
           ", mergeBytesLimit=" + mergeBytesLimit +
           ", mergeSegmentsLimit=" + mergeSegmentsLimit +
           ", maxSegmentsToMove=" + maxSegmentsToMove +
           ", replicantLifetime=" + replicantLifetime +
           ", replicationThrottleLimit=" + replicationThrottleLimit +
           ", balancerComputeThreads=" + balancerComputeThreads +
           ", emitBalancingStats=" + emitBalancingStats +
           ", killUnusedSegmentsInAllDataSources=" + killUnusedSegmentsInAllDataSources +
           ", specificDataSourcesToKillUnusedSegmentsIn=" + specificDataSourcesToKillUnusedSegmentsIn +
           ", dataSourcesToNotKillStalePendingSegmentsIn=" + dataSourcesToNotKillStalePendingSegmentsIn +
           ", maxSegmentsInNodeLoadingQueue=" + maxSegmentsInNodeLoadingQueue +
           ", decommissioningNodes=" + decommissioningNodes +
           ", decommissioningMaxPercentOfMaxSegmentsToMove=" + decommissioningMaxPercentOfMaxSegmentsToMove +
           '}';
  }

  @Override
  public boolean equals(Object o)
  {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }

    CoordinatorDynamicConfig that = (CoordinatorDynamicConfig) o;

    if (leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments !=
        that.leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments) {
      return false;
    }
    if (mergeBytesLimit != that.mergeBytesLimit) {
      return false;
    }
    if (mergeSegmentsLimit != that.mergeSegmentsLimit) {
      return false;
    }
    if (maxSegmentsToMove != that.maxSegmentsToMove) {
      return false;
    }
    if (replicantLifetime != that.replicantLifetime) {
      return false;
    }
    if (replicationThrottleLimit != that.replicationThrottleLimit) {
      return false;
    }
    if (balancerComputeThreads != that.balancerComputeThreads) {
      return false;
    }
    if (emitBalancingStats != that.emitBalancingStats) {
      return false;
    }
    if (killUnusedSegmentsInAllDataSources != that.killUnusedSegmentsInAllDataSources) {
      return false;
    }
    if (maxSegmentsInNodeLoadingQueue != that.maxSegmentsInNodeLoadingQueue) {
      return false;
    }
    if (!Objects.equals(specificDataSourcesToKillUnusedSegmentsIn, that.specificDataSourcesToKillUnusedSegmentsIn)) {
      return false;
    }
    if (!Objects.equals(dataSourcesToNotKillStalePendingSegmentsIn, that.dataSourcesToNotKillStalePendingSegmentsIn)) {
      return false;
    }
    if (!Objects.equals(decommissioningNodes, that.decommissioningNodes)) {
      return false;
    }
    return decommissioningMaxPercentOfMaxSegmentsToMove == that.decommissioningMaxPercentOfMaxSegmentsToMove;
  }

  @Override
  public int hashCode()
  {
    return Objects.hash(
        leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments,
        mergeBytesLimit,
        mergeSegmentsLimit,
        maxSegmentsToMove,
        replicantLifetime,
        replicationThrottleLimit,
        balancerComputeThreads,
        emitBalancingStats,
        killUnusedSegmentsInAllDataSources,
        maxSegmentsInNodeLoadingQueue,
        specificDataSourcesToKillUnusedSegmentsIn,
        dataSourcesToNotKillStalePendingSegmentsIn,
        decommissioningNodes,
        decommissioningMaxPercentOfMaxSegmentsToMove
    );
  }

  public static Builder builder()
  {
    return new Builder();
  }

  public static class Builder
  {
    private static final long DEFAULT_LEADING_TIME_MILLIS_BEFORE_CAN_MARK_AS_UNUSED_OVERSHADOWED_SEGMENTS =
        TimeUnit.MINUTES.toMillis(15);
    private static final long DEFAULT_MERGE_BYTES_LIMIT = 524_288_000L;
    private static final int DEFAULT_MERGE_SEGMENTS_LIMIT = 100;
    private static final int DEFAULT_MAX_SEGMENTS_TO_MOVE = 5;
    private static final int DEFAULT_REPLICANT_LIFETIME = 15;
    private static final int DEFAULT_REPLICATION_THROTTLE_LIMIT = 10;
    private static final int DEFAULT_BALANCER_COMPUTE_THREADS = 1;
    private static final boolean DEFAULT_EMIT_BALANCING_STATS = false;
    private static final boolean DEFAULT_KILL_UNUSED_SEGMENTS_IN_ALL_DATA_SOURCES = false;
    private static final int DEFAULT_MAX_SEGMENTS_IN_NODE_LOADING_QUEUE = 0;
    private static final int DEFAULT_DECOMMISSIONING_MAX_SEGMENTS_TO_MOVE_PERCENT = 70;

    private Long leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments;
    private Long mergeBytesLimit;
    private Integer mergeSegmentsLimit;
    private Integer maxSegmentsToMove;
    private Integer replicantLifetime;
    private Integer replicationThrottleLimit;
    private Boolean emitBalancingStats;
    private Integer balancerComputeThreads;
    private Object specificDataSourcesToKillUnusedSegmentsIn;
    private Boolean killUnusedSegmentsInAllDataSources;
    private Object dataSourcesToNotKillStalePendingSegmentsIn;
    private Integer maxSegmentsInNodeLoadingQueue;
    private Object decommissioningNodes;
    private Integer decommissioningMaxPercentOfMaxSegmentsToMove;

    public Builder()
    {
    }

    @JsonCreator
    public Builder(
        @JsonProperty("millisToWaitBeforeDeleting")
        @Nullable Long leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments,
        @JsonProperty("mergeBytesLimit") @Nullable Long mergeBytesLimit,
        @JsonProperty("mergeSegmentsLimit") @Nullable Integer mergeSegmentsLimit,
        @JsonProperty("maxSegmentsToMove") @Nullable Integer maxSegmentsToMove,
        @JsonProperty("replicantLifetime") @Nullable Integer replicantLifetime,
        @JsonProperty("replicationThrottleLimit") @Nullable Integer replicationThrottleLimit,
        @JsonProperty("balancerComputeThreads") @Nullable Integer balancerComputeThreads,
        @JsonProperty("emitBalancingStats") @Nullable Boolean emitBalancingStats,
        @JsonProperty("killDataSourceWhitelist") @Nullable Object specificDataSourcesToKillUnusedSegmentsIn,
        @JsonProperty("killAllDataSources") @Nullable Boolean killUnusedSegmentsInAllDataSources,
        @JsonProperty("killPendingSegmentsSkipList") @Nullable Object dataSourcesToNotKillStalePendingSegmentsIn,
        @JsonProperty("maxSegmentsInNodeLoadingQueue") @Nullable Integer maxSegmentsInNodeLoadingQueue,
        @JsonProperty("decommissioningNodes") @Nullable Object decommissioningNodes,
        @JsonProperty("decommissioningMaxPercentOfMaxSegmentsToMove")
        @Nullable Integer decommissioningMaxPercentOfMaxSegmentsToMove
    )
    {
      this.leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments =
          leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments;
      this.mergeBytesLimit = mergeBytesLimit;
      this.mergeSegmentsLimit = mergeSegmentsLimit;
      this.maxSegmentsToMove = maxSegmentsToMove;
      this.replicantLifetime = replicantLifetime;
      this.replicationThrottleLimit = replicationThrottleLimit;
      this.balancerComputeThreads = balancerComputeThreads;
      this.emitBalancingStats = emitBalancingStats;
      this.specificDataSourcesToKillUnusedSegmentsIn = specificDataSourcesToKillUnusedSegmentsIn;
      this.killUnusedSegmentsInAllDataSources = killUnusedSegmentsInAllDataSources;
      this.dataSourcesToNotKillStalePendingSegmentsIn = dataSourcesToNotKillStalePendingSegmentsIn;
      this.maxSegmentsInNodeLoadingQueue = maxSegmentsInNodeLoadingQueue;
      this.decommissioningNodes = decommissioningNodes;
      this.decommissioningMaxPercentOfMaxSegmentsToMove = decommissioningMaxPercentOfMaxSegmentsToMove;
    }

    public Builder withLeadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments(long leadingTimeMillis)
    {
      this.leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments = leadingTimeMillis;
      return this;
    }

    public Builder withMergeBytesLimit(long mergeBytesLimit)
    {
      this.mergeBytesLimit = mergeBytesLimit;
      return this;
    }

    public Builder withMergeSegmentsLimit(int mergeSegmentsLimit)
    {
      this.mergeSegmentsLimit = mergeSegmentsLimit;
      return this;
    }

    public Builder withMaxSegmentsToMove(int maxSegmentsToMove)
    {
      this.maxSegmentsToMove = maxSegmentsToMove;
      return this;
    }

    public Builder withReplicantLifetime(int replicantLifetime)
    {
      this.replicantLifetime = replicantLifetime;
      return this;
    }

    public Builder withReplicationThrottleLimit(int replicationThrottleLimit)
    {
      this.replicationThrottleLimit = replicationThrottleLimit;
      return this;
    }

    public Builder withBalancerComputeThreads(int balancerComputeThreads)
    {
      this.balancerComputeThreads = balancerComputeThreads;
      return this;
    }

    public Builder withEmitBalancingStats(boolean emitBalancingStats)
    {
      this.emitBalancingStats = emitBalancingStats;
      return this;
    }

    public Builder withSpecificDataSourcesToKillUnusedSegmentsIn(Set<String> dataSources)
    {
      this.specificDataSourcesToKillUnusedSegmentsIn = dataSources;
      return this;
    }

    public Builder withKillUnusedSegmentsInAllDataSources(boolean killUnusedSegmentsInAllDataSources)
    {
      this.killUnusedSegmentsInAllDataSources = killUnusedSegmentsInAllDataSources;
      return this;
    }

    public Builder withMaxSegmentsInNodeLoadingQueue(int maxSegmentsInNodeLoadingQueue)
    {
      this.maxSegmentsInNodeLoadingQueue = maxSegmentsInNodeLoadingQueue;
      return this;
    }

    public Builder withDecommissioningNodes(Set<String> decommissioning)
    {
      this.decommissioningNodes = decommissioning;
      return this;
    }

    public Builder withDecommissioningMaxPercentOfMaxSegmentsToMove(Integer percent)
    {
      this.decommissioningMaxPercentOfMaxSegmentsToMove = percent;
      return this;
    }

    public CoordinatorDynamicConfig build()
    {
      return new CoordinatorDynamicConfig(
          leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments == null
          ? DEFAULT_LEADING_TIME_MILLIS_BEFORE_CAN_MARK_AS_UNUSED_OVERSHADOWED_SEGMENTS
          : leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments,
          mergeBytesLimit == null ? DEFAULT_MERGE_BYTES_LIMIT : mergeBytesLimit,
          mergeSegmentsLimit == null ? DEFAULT_MERGE_SEGMENTS_LIMIT : mergeSegmentsLimit,
          maxSegmentsToMove == null ? DEFAULT_MAX_SEGMENTS_TO_MOVE : maxSegmentsToMove,
          replicantLifetime == null ? DEFAULT_REPLICANT_LIFETIME : replicantLifetime,
          replicationThrottleLimit == null ? DEFAULT_REPLICATION_THROTTLE_LIMIT : replicationThrottleLimit,
          balancerComputeThreads == null ? DEFAULT_BALANCER_COMPUTE_THREADS : balancerComputeThreads,
          emitBalancingStats == null ? DEFAULT_EMIT_BALANCING_STATS : emitBalancingStats,
          specificDataSourcesToKillUnusedSegmentsIn,
          killUnusedSegmentsInAllDataSources == null
          ? DEFAULT_KILL_UNUSED_SEGMENTS_IN_ALL_DATA_SOURCES
          : killUnusedSegmentsInAllDataSources,
          dataSourcesToNotKillStalePendingSegmentsIn,
          maxSegmentsInNodeLoadingQueue == null
          ? DEFAULT_MAX_SEGMENTS_IN_NODE_LOADING_QUEUE
          : maxSegmentsInNodeLoadingQueue,
          decommissioningNodes,
          decommissioningMaxPercentOfMaxSegmentsToMove == null
          ? DEFAULT_DECOMMISSIONING_MAX_SEGMENTS_TO_MOVE_PERCENT
          : decommissioningMaxPercentOfMaxSegmentsToMove
      );
    }

    public CoordinatorDynamicConfig build(CoordinatorDynamicConfig defaults)
    {
      return new CoordinatorDynamicConfig(
          leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments == null
          ? defaults.getLeadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments()
          : leadingTimeMillisBeforeCanMarkAsUnusedOvershadowedSegments,
          mergeBytesLimit == null ? defaults.getMergeBytesLimit() : mergeBytesLimit,
          mergeSegmentsLimit == null ? defaults.getMergeSegmentsLimit() : mergeSegmentsLimit,
          maxSegmentsToMove == null ? defaults.getMaxSegmentsToMove() : maxSegmentsToMove,
          replicantLifetime == null ? defaults.getReplicantLifetime() : replicantLifetime,
          replicationThrottleLimit == null ? defaults.getReplicationThrottleLimit() : replicationThrottleLimit,
          balancerComputeThreads == null ? defaults.getBalancerComputeThreads() : balancerComputeThreads,
          emitBalancingStats == null ? defaults.emitBalancingStats() : emitBalancingStats,
          specificDataSourcesToKillUnusedSegmentsIn == null
          ? defaults.getSpecificDataSourcesToKillUnusedSegmentsIn()
          : specificDataSourcesToKillUnusedSegmentsIn,
          killUnusedSegmentsInAllDataSources == null
          ? defaults.isKillUnusedSegmentsInAllDataSources()
          : killUnusedSegmentsInAllDataSources,
          dataSourcesToNotKillStalePendingSegmentsIn == null
          ? defaults.getDataSourcesToNotKillStalePendingSegmentsIn()
          : dataSourcesToNotKillStalePendingSegmentsIn,
          maxSegmentsInNodeLoadingQueue == null
          ? defaults.getMaxSegmentsInNodeLoadingQueue()
          : maxSegmentsInNodeLoadingQueue,
          decommissioningNodes == null ? defaults.getDecommissioningNodes() : decommissioningNodes,
          decommissioningMaxPercentOfMaxSegmentsToMove == null
          ? defaults.getDecommissioningMaxPercentOfMaxSegmentsToMove()
          : decommissioningMaxPercentOfMaxSegmentsToMove
      );
    }
  }
}


text:
using System;
using Tellurium.VisualAssertions.Screenshots.Utils;

namespace Tellurium.VisualAssertions.Screenshots
{
    public class TestSessionContext
    {
        private static TestSessionContext current;
        private static object contextLockObject = new object();

        public static TestSessionContext Current
        {
            get
            {
                if (current == null)
                {
                    lock (contextLockObject)
                    {
                        if (current == null)
                        {
                            current = new TestSessionContext()
                            {
                                StartDate = DateTime.Now.TrimToSeconds()
                            };
                        }
                    }
                }
                return current;
            }
            set => current = value;
        }

        public DateTime StartDate { get; private set; }
    }
}


text:
<?php

namespace Ticketmatic\Model;

use Ticketmatic\Json;

/**
 * Set of parameters used to filter price lists.
 *
 * More info: see price list (api/types/PriceList), the getlist operation
 * (api/settings/pricing/pricelists/getlist) and the price lists endpoint
 * (api/settings/pricing/pricelists).
 *
 * ## Help Center
 *
 * Full documentation can be found in the Ticketmatic Help Center
 * (https://apps.ticketmatic.com/#/knowledgebase/api/types/PriceListQuery).
 */
class PriceListQuery implements \jsonSerializable
{
    /**
     * Create a new PriceListQuery
     *
     * @param array $data
     */
    public function __construct(array $data = array()) {
        foreach ($data as $key => $value) {
            $this->$key = $value;
        }
    }

    /**
     * Filter the returned items by specifying a query on the public datamodel that
     * returns the ids.
     *
     * @var string
     */
    public $filter;

    /**
     * If this parameter is true, archived items will be returned as well.
     *
     * @var bool
     */
    public $includearchived;

    /**
     * All items that were updated since this timestamp will be returned. Timestamp
     * should be passed in `YYYY-MM-DD hh:mm:ss` format.
     *
     * @var \DateTime
     */
    public $lastupdatesince;

    /**
     * Unpack PriceListQuery from JSON.
     *
     * @param object $obj
     *
     * @return \Ticketmatic\Model\PriceListQuery
     */
    public static function fromJson($obj) {
        if ($obj === null) {
            return null;
        }

        return new PriceListQuery(array(
            "filter" => isset($obj->filter) ? $obj->filter : null,
            "includearchived" => isset($obj->includearchived) ? $obj->includearchived : null,
            "lastupdatesince" => isset($obj->lastupdatesince) ? Json::unpackTimestamp($obj->lastupdatesince) : null,
        ));
    }

    /**
     * Serialize PriceListQuery to JSON.
     *
     * @return array
     */
    public function jsonSerialize() {
        $result = array();
        if (!is_null($this->filter)) {
            $result["filter"] = strval($this->filter);
        }
        if (!is_null($this->includearchived)) {
            $result["includearchived"] = (bool)$this->includearchived;
        }
        if (!is_null($this->lastupdatesince)) {
            $result["lastupdatesince"] = Json::packTimestamp($this->lastupdatesince);
        }

        return $result;
    }
}


text:
package email.com.gmail.ttsai0509.serialmonitor.config;

import gnu.io.SerialPort;

public enum DataBits {

    DATABITS_5(SerialPort.DATABITS_5),
    DATABITS_6(SerialPort.DATABITS_6),
    DATABITS_7(SerialPort.DATABITS_7),
    DATABITS_8(SerialPort.DATABITS_8);

    public final int val;

    DataBits(int val) {
        this.val = val;
    }

}


text:
import os

basedir = os.path.abspath(os.path.dirname(__file__))

BCRYPT_LOG_ROUNDS = 12

S3_BASE_URL = 'https://s3.ap-northeast-2.amazonaws.com/hjlog-photos/'
S3_BUCKET_NAME = 'hjlog-photos'

# Form
with open('SECRET_KEY') as secret_key:
    SECRET_KEY = secret_key.read().strip()

UPLOAD_FOLDER = 'hjlog/static/image/photo'
ALLOWED_EXTENSIONS = set(['gif', 'jpg', 'jpeg', 'png'])

# SQLAlchemy
if os.environ.get('DATABASE_URL') is None:
    SQLALCHEMY_DATABASE_URI = ('postgresql://hjlog:hjlog@localhost:5432/hjlog')
else:
    SQLALCHEMY_DATABASE_URI = os.environ['DATABASE_URL']

SQLALCHEMY_MIGRATE_REPO = os.path.join(basedir, 'db_repository')
SQLALCHEMY_RECORD_QUERIES = True

# MAX file upload size
MAX_CONTENT_LENGTH = 16 * 1024 * 1024


text:
package org.jetbrains.idea.svn.dialogs;

import com.intellij.openapi.vfs.VirtualFile;
import org.jetbrains.annotations.NotNull;
import org.tmatesoft.svn.core.internal.util.SVNPathUtil;

import java.util.List;

public class WCInfoWithBranches extends WCInfo {

  @NotNull private final List<Branch> myBranches;
  @NotNull private final VirtualFile myRoot;
  private final Branch myCurrentBranch;

  public WCInfoWithBranches(@NotNull WCInfo info, @NotNull List<Branch> branches, @NotNull VirtualFile root, Branch currentBranch) {
    super(info.getRootInfo(), info.isIsWcRoot(), info.getStickyDepth());

    myBranches = branches;
    myRoot = root;
    myCurrentBranch = currentBranch;
  }

  // to be used in combo
  @Override
  public String toString() {
    return getPath();
  }

  @Override
  @NotNull
  public VirtualFile getVcsRoot() {
    return myRoot;
  }

  /**
   * List of all branches according to branch configuration. Does not contain {@code getCurrentBranch()} branch.
   */
  @NotNull
  public List<Branch> getBranches() {
    return myBranches;
  }

  @NotNull
  public VirtualFile getRoot() {
    return myRoot;
  }

  /**
   * Current branch of this working copy instance (working copy url) according to branch configuration.
   */
  public Branch getCurrentBranch() {
    return myCurrentBranch;
  }

  public static class Branch {

    @NotNull private final String myName;
    @NotNull private final String myUrl;

    public Branch(@NotNull String url) {
      myName = SVNPathUtil.tail(url);
      myUrl = url;
    }

    @NotNull
    public String getName() {
      return myName;
    }

    @NotNull
    public String getUrl() {
      return myUrl;
    }

    @Override
    public String toString() {
      return myName;
    }

    @Override
    public boolean equals(final Object o) {
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;

      Branch branch = (Branch)o;

      return myUrl.equals(branch.myUrl);
    }

    @Override
    public int hashCode() {
      return myUrl.hashCode();
    }
  }
}


text: UI challenge for Apple WatchKit.


text:
<?php

namespace Zimbra\Admin\Request;

use Zimbra\Enum\VolumeType;

/**
 * SetCurrentVolume request class
 * Set current volume.
 *
 * @package    Zimbra
 * @subpackage Admin
 * @category   Request
 * @author     Nguyen Van Nguyen - nguyennv1981@gmail.com
 * @copyright  Copyright © 2013 by Nguyen Van Nguyen.
 */
class SetCurrentVolume extends Base
{
    /**
     * Constructor method for SetCurrentVolume
     * @param int $id ID
     * @param string $type Volume type: 1 (primary message), 2 (secondary message) or 10 (index)
     * @return self
     */
    public function __construct($id, VolumeType $type)
    {
        parent::__construct();
        $this->setProperty('id', (int) $id);
        $this->setProperty('type', $type);
    }

    /**
     * Gets ID
     *
     * @return int
     */
    public function getId()
    {
        return $this->getProperty('id');
    }

    /**
     * Sets ID
     *
     * @param  int $id
     * @return self
     */
    public function setId($id)
    {
        return $this->setProperty('id', (int) $id);
    }

    /**
     * Gets type
     *
     * @return VolumeType
     */
    public function getType()
    {
        return $this->getProperty('type');
    }

    /**
     * Sets type
     *
     * @param  VolumeType $type
     * @return self
     */
    public function setType(VolumeType $type)
    {
        return $this->setProperty('type', $type);
    }
}


text:
using McMaster.Extensions.CommandLineUtils;
using NuGet.Common;

namespace NupkgWrench
{
    internal static class NuspecCommand
    {
        public static void Register(CommandLineApplication cmdApp, ILogger log)
        {
            var parentCommand = cmdApp.Command("nuspec", (cmd) => Run(cmd, log), throwOnUnexpectedArg: true);

            EditCommand.Register(parentCommand, log);
            ShowCommand.Register(parentCommand, log);
            ContentFilesCommand.Register(parentCommand, log);
            DependenciesCommand.Register(parentCommand, log);
            FrameworkAssembliesCommand.Register(parentCommand, log);
        }

        private static void Run(CommandLineApplication cmd, ILogger log)
        {
            cmd.Description = "Nuspec commands.";

            cmd.HelpOption(Constants.HelpOption);

            cmd.OnExecute(() =>
            {
                cmd.ShowHelp();

                return 0;
            });
        }
    }
}


text:
using ZyGames.Framework.Game.Contract;
using ZyGames.Framework.Game.Contract.Action;

namespace ZyGames.Doudizhu.Bll.Action
{
    /// <summary>
    /// 360获取Token接口
    /// </summary>
    public class Action360 : ReAccessTokenAction
    {
        public Action360(HttpGet httpGet)
            : base(ActionIDDefine.Cst_Action360, httpGet)
        {
        }
    }
}


text:
package org.flexiblepower.ral.ext;

import java.util.List;

import org.flexiblepower.messaging.Connection;
import org.flexiblepower.messaging.MessageHandler;
import org.flexiblepower.ral.ControllerManager;
import org.flexiblepower.ral.ResourceControlParameters;
import org.flexiblepower.ral.ResourceDriver;
import org.flexiblepower.ral.ResourceManager;
import org.flexiblepower.ral.ResourceState;
import org.flexiblepower.ral.messages.AllocationStatusUpdate;
import org.flexiblepower.ral.messages.ResourceMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Gives a basic implementation for a {@link ResourceManager} which does simple translation, possible while keeping
 * state information.
 */
public abstract class AbstractResourceManager<RS extends ResourceState, RCP extends ResourceControlParameters> implements
                                                                                ResourceManager {
    /**
     * The logger that should be used by any subclass.
     */
    protected final Logger logger;

    /**
     * Creates a new instance for the specific driver class type and the control space class.
     */
    protected AbstractResourceManager() {
        logger = LoggerFactory.getLogger(getClass());
    }

    private volatile boolean hasRegistered = false;

    protected abstract List<? extends ResourceMessage> startRegistration(RS state);

    protected abstract List<? extends ResourceMessage> updatedState(RS state);

    protected abstract RCP receivedAllocation(ResourceMessage message);

    private volatile Connection driverConnection, controllerConnection;

    @Override
    public MessageHandler onConnect(Connection connection) {
        if (driverConnection == null && "driver".equals(connection.getPort().name())) {
            driverConnection = connection;
            return new MessageHandler() {
                @SuppressWarnings("unchecked")
                @Override
                public void handleMessage(Object message) {
                    try {
                        if (controllerConnection != null) {
                            List<? extends ResourceMessage> messages = null;
                            if (!hasRegistered) {
                                messages = startRegistration((RS) message);
                                hasRegistered = true;
                            } else {
                                messages = updatedState((RS) message);
                            }

                            if (messages != null) {
                                for (ResourceMessage msg : messages) {
                                    if (msg == null) {
                                        logger.warn("Trying to send a null message, this is not allowed");
                                    } else {
                                        controllerConnection.sendMessage(msg);
                                    }
                                }
                            }
                        }
                        else {
                            logger.warn("Message Received by Resource Manager but no controler connected");
                        }
                    } catch (ClassCastException ex) {
                        logger.warn("Received unknown message type {}", message.getClass().getName());
                    }
                }

                @Override
                public void disconnected() {
                    hasRegistered = false;
                    driverConnection = null;
                }
            };
        } else if (controllerConnection == null && "controller".equals(connection.getPort().name())) {
            controllerConnection = connection;
            return new MessageHandler() {
                @Override
                public void handleMessage(Object message) {
                    try {
                        if (driverConnection != null) {
                            RCP control = receivedAllocation((ResourceMessage) message);
                            if (control != null) {
                                driverConnection.sendMessage(control);
                            }
                        }
                        else {
                            logger.warn("Message Received by Resource Manager but no driver connected");
                        }
                    } catch (ClassCastException ex) {
                        logger.warn("Received unknown message type {}", message.getClass().getName());
                    }

                }

                @Override
                public void disconnected() {
                    hasRegistered = false;
                    controllerConnection = null;
                }
            };
        }
        return null;
    }

    /**
     * Indicate if this {@link ResourceManager} is currently connected to a {@link ControllerManager}
     *
     * @return boolean indicating if this {@link ResourceManager} is currently connected to a {@link ControllerManager}
     */
    protected boolean isConnectedWithResourceController() {
        return controllerConnection != null;
    }

    /**
     * Indicate if this {@link ResourceManager} is currently connected to a {@link ResourceDriver}
     *
     * @return boolean indicating if this {@link ResourceManager} is currently connected to a {@link ResourceDriver}
     */
    protected boolean isConnectedWithResourceDriver() {
        return driverConnection != null;
    }

    /**
     * Send status update to attached controller
     *
     * @param allocationStatusUpdate
     */
    protected void allocationStatusUpdate(AllocationStatusUpdate allocationStatusUpdate) {
        if (controllerConnection != null) {
            controllerConnection.sendMessage(allocationStatusUpdate);
        }
        else {
            logger.warn("Allocation Status update from Resource Manager but no controller connected");
        }

    }

    /**
     * Send control parameters to attached driver
     *
     * @param controlParameters
     *            The parameters that have to be sent to the driver
     */
    protected void sendControlParameters(ResourceControlParameters controlParameters) {
        if (driverConnection != null) {
            driverConnection.sendMessage(controlParameters);
        }
        else {
            logger.warn("Control Parameters update from Resource Manager but no controller connected");
        }
    }

}