text:
var mgr = {},
    norm = {},
    queue = {},
    lib = {},
    core = {};

( function ( mgr, norm ) {
    "use strict";

    /**
     * API
     */

    $.fn.scrollable = function () {
        return getScrollable( this );
    };

    $.fn.scrollRange = function ( axis ) {
        return getScrollRange( this, axis );
    };

    $.fn.scrollTo = function ( position, options ) {
        scrollTo( this, position, options );
        return this;
    };

    $.fn.stopScroll = function ( options ) {
        stopScroll( this, options );
        return this;
    };

    $.fn.notifyScrollCallbacks = function ( message, callbackNames, queueName ) {
        notifyScrollCallbacks( this, message, callbackNames, queueName );
        return this;
    };

    $.scrollable = {
        lockSpeedBelow: 400,
        defaultDuration: $.fx.speeds._default,

        userScrollThreshold: 10,

        // Internal config. Do not modify in production.
        _scrollDetectionThreshold: 5,
        _enableUserScrollDetection: !isIOS(),
        _enableClickAndTouchDetection: true,
        _useScrollHistoryForDetection: isIOS()
    };

    /**
     * Does the actual work of $.fn.scrollable.
     *
     * @param   {jQuery} $container
     * @returns {jQuery}
     */
    function getScrollable ( $container ) {
        $container = norm.normalizeContainer( $container );
        return mgr.getScrollable( $container );
    }

    /**
     * Does the actual work of $.fn.scrollRange.
     *
     * @param   {jQuery} $container
     * @param   {string} axis
     * @returns {number|Object}
     */
    function getScrollRange( $container, axis ) {
        $container = norm.normalizeContainer( $container );
        axis = axis ? norm.normalizeAxisName( axis ) : norm.BOTH_AXES;

        return mgr.getScrollRange( $container, axis );
    }

    /**
     * Does the actual work of $.fn.scrollTo.
     *
     * @param {jQuery}               $container
     * @param {number|string|Object} position
     * @param {Object}               [options]
     */
    function scrollTo ( $container, position, options ) {
        options = norm.normalizeOptions( options, position );
        $container = norm.normalizeContainer( $container );
        position = norm.normalizePosition( position, $container, mgr.getScrollable( $container ), options );

        mgr.scrollTo( $container, position, options );
    }

    /**
     * Does the actual work of $.fn.stopScroll.
     *
     * @param {jQuery}         $container
     * @param {Object}         [options]
     * @param {boolean}        [options.jumpToTargetPosition=false]
     * @param {Object}         [options.notifyCancelled]
     * @param {string|boolean} [options.queue]                       usually not required, set to the scroll queue by default
     */
    function stopScroll( $container, options ) {
        $container = norm.normalizeContainer( $container );
        options = norm.normalizeOptions( options );
        mgr.stopScroll( $container, options );
    }

    /**
     * Does the actual work of $.fn.notifyScrollCallbacks.
     *
     * @param {jQuery}          $container
     * @param {Object}          message
     * @param {string|string[]} [callbackNames]  defaults to all exit callbacks ("complete", "done", "fail", "always")
     * @param {string}          [queueName]      usually not required, set to the scroll queue by default
     */
    function notifyScrollCallbacks ( $container, message, callbackNames, queueName ) {
        $container = norm.normalizeContainer( $container );
        if ( callbackNames !== undefined && !$.isArray( callbackNames ) ) callbackNames = [callbackNames];
        mgr.notifyScrollCallbacks( $container, message, callbackNames, queueName );
    }

    /**
     * Detects if the browser is on iOS. Works for Safari as well as other browsers, say, Chrome on iOS.
     *
     * Required for some iOS behaviour which can't be feature-detected in any way.
     *
     * @returns {boolean}
     */
    function isIOS () {
        return (/iPad|iPhone|iPod/gi).test( navigator.userAgent );
    }

} )( mgr, norm );


text:
    // Motion is a vectorField of all moving boundary points
    vectorField motion(ms.movingPoints().size(), vector::zero);

    vectorField oldPoints = ms.movingPoints();

    scalar oldTime = time_.value() - time_.deltaT().value();
    scalar curTime = time_.value();

    scalar alphaOld   = 0.0;
    scalar alphaCur   = 0.0;

//     scalar rotationAmplitude_(0.707);
//     scalar rotationFrequency_(0.0);
//     vector translationFrequency_(0.0,0.25,0.0);
//     vector translationAmplitude_(0.0,5.0,0.0);
//     vector initialRotationOrigin_(0.0,0.0,0.0);

    scalar pi=3.141592;

    alphaOld = rotationAmplitude_*Foam::sin(2*pi*rotationFrequency_*oldTime);
    alphaCur = rotationAmplitude_*Foam::sin(2*pi*rotationFrequency_*curTime);

    vector translationVector
    (
        translationAmplitude_[0]*
        (
            Foam::sin(2*pi*translationFrequency_[0]*curTime)
          - Foam::sin(2*pi*translationFrequency_[0]*oldTime)
        ),
        translationAmplitude_[1]*
        (
            Foam::sin(2*pi*translationFrequency_[1]*curTime)
          - Foam::sin(2*pi*translationFrequency_[1]*oldTime)
        ),
        0
    );

    tensor RzOld
    (
        Foam::cos(alphaOld), -Foam::sin(alphaOld), 0,
        Foam::sin(alphaOld),  Foam::cos(alphaOld), 0,
        0, 0, 1
    );

    tensor RzCur
    (
        Foam::cos(alphaCur), -Foam::sin(alphaCur), 0,
        Foam::sin(alphaCur),  Foam::cos(alphaCur), 0,
        0, 0, 1
    );

    vectorField rotationField
    (
        (RzCur - RzOld)
      & (statPoints_ - initialRotationOrigin_)
    );

    motion = translationVector + rotationField;

redpajama_set_name: RedPajamaGithub


text:
'use strict';

const assert = require('assert');
const _ = require('lodash');

const Plugin = require('../../lib/plugins/Plugin');

describe('Plugin', function() {
    it('commands', function (done) {
        let plugin = new Plugin();
        console.log(JSON.stringify(plugin.commands(), null, 3));
        done();
    });
    it('hooks', function (done) {
        let plugin = new Plugin();
        console.log(JSON.stringify(plugin.hooks(), null, 3));
        plugin.hooks()['before:templates'][0]('', done);
    });
});


text:
"""Contains optimizer base class."""

def _vectorize(fct):
    """Vectorize function so that it operates on and returns a list."""
    # TODO: parallelize this with multiprocessing (but make that configurable)
    # also, this (entire concept) doesn't exactly seem pretty
    # principle of least astonishment and whatnot

    def vectorized_function(list_of_args):  # pylint: disable=missing-docstring
        return [fct(arg) for arg in list_of_args]

    vectorized_function.__doc__ = fct.__doc__
    return vectorized_function

class Optimizer:
    """Base class for mathematical heuristic_optimization procedures.

    We always use a vectorized objective function, i.e., function
    evaluation is performed in batches. For some functions, this can
    enable better performance.

    Args:
        objective_function: Function to be minimized.
        obj_fct_is_vectorized: Boolean indicating whether the objective
            function is already vectorized.
    """

    def __init__(self, objective_function, obj_fct_is_vectorized=False):
        if not obj_fct_is_vectorized:
            objective_function = _vectorize(objective_function)
        self._vectorized_objective_function = objective_function

        self.historic_best_score = None
        self.historic_best_position = None

    def optimize(self):
        """Return argmin and min of the objective function."""
        raise NotImplementedError

    def compute_scores(self, positions):
        """Evaluate objective function at given positions.

        Args:
            positions: Iterable of arguments for the objective
                function.
        """
        scores = self._vectorized_objective_function(positions)
        self._update_historic_best(positions, scores)
        return scores

    def _update_historic_best(self, positions, scores):
        best_index, best_score = min(enumerate(scores), key=lambda x: x[1])
        if self.historic_best_score is None or best_score < self.historic_best_score:
            self.historic_best_score = best_score
            self.historic_best_position = positions[best_index]


text:
SYNONYM

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

#### Published in
Ann. Acad. Sci. fenn. , Ser. A 15(6): 176 (1921)

#### Original name
Thelotrema marivelense Vain.

### Remarks
null


text:
    <title>Development Team</title>

Project Lead

Dan North

The Team

Aslak Hellesøy

Jörg Schaible

Paul Hammant

Juan Li

Tianshuo Deng

Contributors

Aaron Knauf

Philipp Meier

Conrad Benham

Please direct all correspondence about ProxyToys to the users' mailing lists
    rather than directly to one of the team.


text:
%% F4envmean
% Objective function for computing the envelope subspace.

%% Syntax
%         f = F4envmean(R, DataParameter)
%
%% Input
%
% *R*: A p by u semi orthogonal matrix, 0 < u <= p.
%
% *DataParameter*: A structure that contains the statistics calculated from
% the data.
%
%% Output
%
% *f*: A scalar containing the value of the objective function evaluated at
% R.

%% Description
%
% The objective function is derived by maximum likelihood estimation.
% The columns of the semi-orthogonal matrix that minimizes this function
% span the estimated envelope subspace.

function f = F4envmean(R, DataParameter)

n = DataParameter.n;
p = DataParameter.p;
sY = DataParameter.sY;
sigY = DataParameter.sigY;
logDetSY = DataParameter.logDetSY;

eigtem = eig(R' * sigY * R);
a = log(prod(eigtem(eigtem > 0)));

eigtem0 = eig(R' * inv(sY) * R);
b = log(prod(eigtem0(eigtem0 > 0)));

f = n * p * (1 + log(2 * pi)) + n * (a + b + logDetSY);


text:
/**
 * @module easelts
 */
export interface ISize {
    width: number;
    height: number;
}


text:
"""
```
one_draw(m::AbstractDSGEModel, data::Matrix{Float64}; use_chand_recursion::Bool = true,
         verbose::Symbol = :low)
```
Finds and returns one valid draw from parameter distribution, along with its log likelihood and log posterior.
"""
function one_draw(m::AbstractDSGEModel, data::Matrix{Float64};
                  use_chand_recursion::Bool = true, verbose::Symbol = :low)
    success    = false
    draw       = vec(rand(m.parameters, 1))
    draw_loglh = draw_logpost = 0.0

    while !success
        try
            update!(m, draw)
            draw_loglh = likelihood(m, data, catch_errors = true,
                                    use_chand_recursion = use_chand_recursion,
                                    verbose = verbose)
            draw_logpost = prior(m)
            if (draw_loglh == -Inf) | (draw_loglh === NaN)
                draw_loglh = draw_logpost = -Inf
            end
        catch err
            if isa(err, ParamBoundsError)
                draw_loglh = draw_logpost = -Inf
            elseif isa(err, PosDefException) || isa(err, SingularException) ||
                   isa(err, LinearAlgebra.LAPACKException) || isa(err, DSGE.SteadyStateConvergenceError)
                draw_loglh = draw_logpost = -Inf
            else
                throw(err)
            end
        end
        if any(isinf.(draw_loglh))
            draw = vec(rand(m.parameters, 1))
        else
            success = true
        end
    end
    return vector_reshape(draw, draw_loglh, draw_logpost)
end

"""
```
initial_draw!(m::AbstractDSGEModel, data::Matrix{Float64}, c::ParticleCloud)
initial_draw!(m::AbstractDSGEModel, data::Matrix{Float64}, c::Cloud)
```

Draw from a general starting distribution (set by default to be from the prior) to
initialize the SMC algorithm. Returns a tuple (logpost, loglh) and modifies the
particle objects in the particle cloud in place.
"""
function initial_draw!(m::AbstractModel, data::Matrix{Float64},
                       c::Union{Cloud, ParticleCloud};
                       parallel::Bool = false, use_chand_recursion::Bool = true,
                       verbose::Symbol = :low)
    n_parts = length(c)

    # ================== Define closure on one_draw function ==================
    sendto(workers(), m = m)
    sendto(workers(), data = data)
    sendto(workers(), verbose = verbose)
    sendto(workers(), use_chand_recursion = use_chand_recursion)

    one_draw_closure() = one_draw(m, data; use_chand_recursion = use_chand_recursion,
                                  verbose = verbose)
    @everywhere one_draw_closure() = one_draw(m, data;
                                              use_chand_recursion = use_chand_recursion,
                                              verbose = verbose)
    # =========================================================================

    # For each particle, finds valid parameter draw and returns likelihood & posterior
    draws, loglh, logpost = if parallel
        @sync @distributed (vector_reduce) for i in 1:n_parts
            one_draw_closure()
        end
    else
        vector_reduce([one_draw_closure() for i in 1:n_parts]...)
    end

    update_draws!(c, draws)
    update_loglh!(c, vec(loglh))
    update_logpost!(c, vec(logpost))
    update_old_loglh!(c, zeros(n_parts))
    # Need to call `set_weights` as opposed to `update_weights`
    # since update_weights will multiply and 0*anything = 0
    set_weights!(c, ones(n_parts))
end

"""
```
function draw_likelihood(m, data, draw_vec; verbose::Symbol = :low)
```
Computes likelihood of a particular parameter draw; returns loglh and logpost.
"""
function draw_likelihood(m::AbstractDSGEModel, data::Matrix{Float64},
                         draw_vec::Vector{Float64}; verbose::Symbol = :low)
    update!(m, draw_vec)
    loglh   = likelihood(m, data, verbose = verbose)
    logpost = prior(m)
    return scalar_reshape(loglh, logpost)
end

"""
```
initialize_likelihoods!(m::AbstractDSGEModel, data::Matrix{Float64},
                        c::Union{Cloud, ParticleCloud};
                        parallel::Bool = false, verbose::Symbol = :low)
```
This function is made for transfering the log-likelihood values saved in the
Cloud from a previous estimation to each particle's respective old_loglh
field, and for evaluating/saving the likelihood and posterior at the new data, which
here is just the argument, data.
"""
function initialize_likelihoods!(m::AbstractDSGEModel, data::Matrix{Float64},
                                 c::Union{Cloud, ParticleCloud};
                                 parallel::Bool = false, verbose::Symbol = :low)
    n_parts = length(c)
    draws = (typeof(c) <: Cloud) ? get_vals(c; transpose = false) : Matrix{Float64}(get_vals(c)')

    # Retire log-likelihood values from the old estimation to the field old_loglh
    update_old_loglh!(c, get_loglh(c))

    # ============== Define closure on draw_likelihood function ===============
    sendto(workers(), m = m)
    sendto(workers(), data = data)
    sendto(workers(), verbose = verbose)

    draw_likelihood_closure(draw::Vector{Float64}) = draw_likelihood(m, data, draw;
                                                                 verbose = verbose)
    @everywhere draw_likelihood_closure(draw::Vector{Float64}) = draw_likelihood(m, data,
                                                                 draw; verbose = verbose)
    # =========================================================================

    # TODO: handle when the likelihood with new data cannot be evaluated (returns -Inf),
    # even if the likelihood was not -Inf prior to incorporating new data
    loglh, logpost = if parallel
        @sync @distributed (scalar_reduce) for i in 1:n_parts
            draw_likelihood_closure(draws[i, :])
        end
    else
        scalar_reduce([draw_likelihood_closure(draws[i, :]) for i in 1:n_parts]...)
    end
    update_loglh!(c, loglh)
    update_logpost!(c, logpost)
end

"""
```
function initialize_cloud_settings!(m::AbstractDSGEModel, cloud::ParticleCloud;
                                    tempered_update::Bool = false)
```
Initializes stage index, number of Φ stages, c, resamples, acceptance, and sampling time.
"""
function initialize_cloud_settings!(m::AbstractDSGEModel,
                                    cloud::Union{ParticleCloud,Cloud};
                                    tempered_update::Bool = false)
    if tempered_update
        cloud.ESS = [cloud.ESS[end]]
    else
        cloud.ESS[1] = get_setting(m, :n_particles)
    end
    cloud.stage_index = 1
    cloud.n_Φ         = get_setting(m, :n_Φ)
    cloud.resamples   = 0
    cloud.c           = get_setting(m, :step_size_smc)
    cloud.accept      = get_setting(m, :target_accept)
    cloud.total_sampling_time = 0.
    cloud.tempering_schedule  = zeros(1)
end


text:
package code.model

import net.liftweb.mapper.By
import net.liftweb.mapper.LongKeyedMapper
import net.liftweb.mapper.LongKeyedMetaMapper
import net.liftweb.mapper.MappedLongIndex
import net.liftweb.mapper.MappedString

import code.comet.LogServer

class Preference extends LongKeyedMapper[Preference] {

  def getSingleton = Preference

  def primaryKeyField = id
  object id extends MappedLongIndex(this)
  object name extends MappedString(this, 40)
  object value extends MappedString(this, 40)
}

object Preference extends Preference with LongKeyedMetaMapper[Preference] {

  val maxRecords = "maxRecords"

  def getValue(name: String): Option[Preference] = {
    val values = Preference.findAll(By(Preference.name, name))
    if (values.size > 0) Some(values(0)) else None
  }

  def setValue(name: String, value: String) = {
    val p = Preference.create
    p.name(name)
    p.value(value)
    p.save()
    LogServer ! p
  }

}


text:
package com.jlj.model;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 * Phototype entity.
 *
 * @author MyEclipse Persistence Tools
 */
@Entity
@Table(name = "phototype", catalog = "wcg")
public class Phototype implements java.io.Serializable {

	// Fields

	private Integer id;
	private String name;
	private String publicaccount;
	private Set<Photo> photos = new HashSet<Photo>(0);

	// Constructors

	/** default constructor */
	public Phototype() {
	}

	/** full constructor */
	public Phototype(String name, String publicaccount, Set<Photo> photos) {
		this.name = name;
		this.publicaccount = publicaccount;
		this.photos = photos;
	}

	// Property accessors
	@Id
	@GeneratedValue
	@Column(name = "id", unique = true, nullable = false)
	public Integer getId() {
		return this.id;
	}

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

	@Column(name = "name", length = 50)
	public String getName() {
		return this.name;
	}

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

	@Column(name = "publicaccount", length = 30)
	public String getPublicaccount() {
		return this.publicaccount;
	}

	public void setPublicaccount(String publicaccount) {
		this.publicaccount = publicaccount;
	}

	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "phototype")
	public Set<Photo> getPhotos() {
		return this.photos;
	}

	public void setPhotos(Set<Photo> photos) {
		this.photos = photos;
	}

}


text:
/**
 * @author Alexander Langer
 */
#ifndef SEQUOIA_APPLY_DYNSTEP_ASSIGNMENTS_H
#define SEQUOIA_APPLY_DYNSTEP_ASSIGNMENTS_H

#include "sequoia_solver.h"

namespace sequoia {

template <typename ApplyGame, typename Solver>
class ApplyDynStepAssignment {
public:
    typedef typename ApplyGame::ApplyGameInfo ApplyGameInfo;
    ApplyDynStepAssignment<ApplyGame, Solver>(Solver *solver,
	const TreeDecomposition::vertex_descriptor& node,
	const ConstantSymbol *terminal_symbol,
	const ApplyGameInfo &game_info)
    : _solver(solver), _node(node), _terminal_symbol(terminal_symbol),
      _game_info(game_info) { }
    typedef SequoiaTable::const_iterator::value_type argument_type;
    void operator() (const argument_type &entry);
private:
    Solver *_solver;
    const TreeDecomposition::vertex_descriptor& _node;
    const ConstantSymbol *_terminal_symbol;
    const ApplyGameInfo &_game_info;
    // forbid
    ApplyDynStepAssignment<ApplyGame, Solver>(const ApplyDynStepAssignment<ApplyGame, Solver> &);
};

} // namespace

#include "apply_dynstep_assignments.hpp"

#endif // SEQUOIA_APPLY_DYNSTEP_ASSIGNMENTS_H


text:
package com.linkedin.norbert
package network
package server

import org.specs.Specification
import org.specs.mock.Mockito
import cluster._
import network.common.SampleMessage
import scala.collection.mutable.MutableList

class NetworkServerSpec extends Specification with Mockito with SampleMessage {
  val networkServer = new NetworkServer with ClusterClientComponent with ClusterIoServerComponent with MessageHandlerRegistryComponent
      with MessageExecutorComponent {
    val clusterIoServer = mock[ClusterIoServer]
    val clusterClient = mock[ClusterClient]
    val messageHandlerRegistry = mock[MessageHandlerRegistry]
    val messageExecutor = mock[MessageExecutor]
  }

  val node = Node(1, "", false)
  val listenerKey: ClusterListenerKey = ClusterListenerKey(1)
  networkServer.clusterClient.nodeWithId(1) returns Some(node)
  networkServer.clusterClient.addListener(any[ClusterListener]) returns listenerKey

  "NetworkServer" should {
    "throw a NetworkShutdownException if the network has been shutdown" in {
      networkServer.shutdown
      networkServer.bind(1) must throwA[NetworkShutdownException]
      networkServer.bind(1, false) must throwA[NetworkShutdownException]
      networkServer.markAvailable must throwA[NetworkShutdownException]
      networkServer.markUnavailable must throwA[NetworkShutdownException]
      networkServer.myNode must throwA[NetworkShutdownException]
    }

    "throw a NetworkServerNotBound exception if bind has not be called" in {
      networkServer.myNode must throwA[NetworkServerNotBoundException]
      networkServer.markUnavailable must throwA[NetworkServerNotBoundException]
      networkServer.markAvailable must throwA[NetworkServerNotBoundException]
    }

    "register messages with the MessageHandlerRegistry" in {
      doNothing.when(networkServer.messageHandlerRegistry).registerHandler((ping: Ping) => new Ping)

      networkServer.registerHandler((ping : Ping) => new Ping)
    }

    "add filters with the MessageExcutor" in {
      val filters = mock[List[Filter]]
      doNothing.when(networkServer.messageExecutor).addFilters(filters)

      networkServer.addFilters(filters)
      there was one(networkServer.messageExecutor).addFilters(filters)
    }

    "when bind is called" in {
      "start the cluster client, await the completion and register as a listener" in {
        doNothing.when(networkServer.clusterClient).start
        doNothing.when(networkServer.clusterClient).awaitConnectionUninterruptibly

        networkServer.bind(1)

        got {
          one(networkServer.clusterClient).start
          one(networkServer.clusterClient).awaitConnectionUninterruptibly
          one(networkServer.clusterClient).addListener(any[ClusterListener])
        }
      }

      "bind to the socket" in {
        doNothing.when(networkServer.clusterIoServer).bind(node, true)

        networkServer.bind(1)

        there was one(networkServer.clusterIoServer).bind(node, true)
      }

      "throw an InvalidNodeException if the nodeId doesn't exist" in {
        networkServer.clusterClient.nodeWithId(1) returns None

        networkServer.bind(1) must throwA[InvalidNodeException]
      }

      "if markAvailable is true, mark the node available when a Connection message is received" in {
        var listener: ClusterListener = null
        networkServer.clusterClient.addListener(any[ClusterListener]) answers { l => listener = l.asInstanceOf[ClusterListener]; ClusterListenerKey(1) }
        doNothing.when(networkServer.clusterClient).markNodeAvailable(1)

        networkServer.bind(1)

        listener.handleClusterEvent(ClusterEvents.Connected(Set()))

        there was one(networkServer.clusterClient).markNodeAvailable(1, 0)
      }

      "if markAvailable is false, not mark the node available when a Connection message is received" in {
        var listener: ClusterListener = null
        networkServer.clusterClient.addListener(any[ClusterListener]) answers { l => listener = l.asInstanceOf[ClusterListener]; ClusterListenerKey(1) }
        doNothing.when(networkServer.clusterClient).markNodeAvailable(1)

        networkServer.bind(1, false)

        listener.handleClusterEvent(ClusterEvents.Connected(Set()))

        there was no(networkServer.clusterClient).markNodeAvailable(1, 0)
      }
    }

    "return the node associated with the nodeId bound to for myNode" in {
      networkServer.bind(1)

      networkServer.myNode must be_==(node)
    }

    "mark the node available and ensure it stays available when Connected events are received for markAvailable" in {
      var listener: ClusterListener = null
      networkServer.clusterClient.addListener(any[ClusterListener]) answers { l => listener = l.asInstanceOf[ClusterListener]; ClusterListenerKey(1) }
      doNothing.when(networkServer.clusterClient).markNodeAvailable(1)

      networkServer.bind(1, false)

      listener.handleClusterEvent(ClusterEvents.Connected(Set()))

      networkServer.markAvailable

      there was one(networkServer.clusterClient).markNodeAvailable(1, 0)

      listener.handleClusterEvent(ClusterEvents.Connected(Set()))

      there were two(networkServer.clusterClient).markNodeAvailable(1, 0)
    }

    "mark the node unavailable and ensure it is not marked available when Connected events are received for markUnavailable" in {
      var listener: ClusterListener = null
      networkServer.clusterClient.addListener(any[ClusterListener]) answers { l => listener = l.asInstanceOf[ClusterListener]; ClusterListenerKey(1) }
      doNothing.when(networkServer.clusterClient).markNodeAvailable(1)
      doNothing.when(networkServer.clusterClient).markNodeUnavailable(1)

      networkServer.bind(1)

      listener.handleClusterEvent(ClusterEvents.Connected(Set()))

      there was one(networkServer.clusterClient).markNodeAvailable(1, 0)

      networkServer.markUnavailable

      listener.handleClusterEvent(ClusterEvents.Connected(Set()))

      got {
        one(networkServer.clusterClient).markNodeAvailable(1, 0)
        one(networkServer.clusterClient).markNodeUnavailable(1)
      }
    }

    "shutdown the cluster io server, mark unavailable, and remove the cluster listener if shutdown is called" in {
      doNothing.when(networkServer.clusterIoServer).shutdown
      doNothing.when(networkServer.clusterClient).markNodeUnavailable(1)
      doNothing.when(networkServer.clusterClient).removeListener(listenerKey)

      networkServer.bind(1)
      networkServer.shutdown

      got {
        one(networkServer.clusterIoServer).shutdown
        one(networkServer.clusterClient).markNodeUnavailable(1)
        one(networkServer.clusterClient).removeListener(listenerKey)
      }
    }

    "shutdown the cluster io server if a Shutdown event is received" in {
      var listener: ClusterListener = null
      networkServer.clusterClient.addListener(any[ClusterListener]) answers { l => listener = l.asInstanceOf[ClusterListener]; ClusterListenerKey(1) }
      doNothing.when(networkServer.clusterIoServer).shutdown
      doNothing.when(networkServer.clusterClient).markNodeUnavailable(1)
      doNothing.when(networkServer.clusterClient).removeListener(listenerKey)

      networkServer.bind(1)
      listener.handleClusterEvent(ClusterEvents.Shutdown)

      there was one(networkServer.clusterIoServer).shutdown
      there was no(networkServer.clusterClient).markNodeUnavailable(1)
      there was no(networkServer.clusterClient).removeListener(listenerKey)
    }
  }
}


text:
| Property | Description | Type | Default |
| -------- | ----------- | ---- | ------- |
| `[page]` | Current page number. | number | |
| `[total]` | Total number of **items** in all pages. | number | |
| `[limit]` | Limit number of visible pages. A value less than 1 indicates that there is no limitation. | number |  0 |
| `[boundaryLinks]` | Whether to display First and Last buttons. | boolean | false |
| `[boundaryNumbers]` | Define how many of the first and last page numbers to always show. | boolean | 0 |
| `[perPage]` | Maximum number of items per page. | boolean | 10 |
| `[firstText]` | Displayed string for First button. | string | 'First' |
| `[previousText]` | Displayed string for Previous button. | string | 'Previous' |
| `[previousText]` | Displayed string for Previous button. | string | 'Previous' |
| `[nextText]` | Displayed string for Next button. | string | 'Next' |
| `[lastText]` | Displayed string for Last button. | string | 'Last' |
| `(pageChange)` | The page clicked in order to select. | EventEmitter<number> | |

### Export API

| Name | Description | Type |
| -------- | ----------- | ---- |
| `start` | Starting row index of current page. | number |
| `end` | Last row index of current page. | number |


text:
ExcelTool是一个能根据参考行列快速地进行拼接,分割Excel文件的工具。界面简洁,操作简单

a tool to conditional slice or paste .xls,.xlsx in a quik,simplify way

##条件拼接 Conditional Paste
以paste01.xlsm和paste02.xlsm第一列(A column)进行文件拼接

![paset01](https://github.com/misuqian/ExcelTool/blob/master/png/paste01.png) **+**
![paset02](https://github.com/misuqian/ExcelTool/blob/master/png/paste02.png) __=__
![paset_result](https://github.com/misuqian/ExcelTool/blob/master/png/paste_result.png)

__你只需要根据界面简单设置__ [paste_config](https://github.com/misuqian/ExcelTool/blob/master/png/paste_config.png)

##条件切割 Conditional Slice
以slice_refer.xlsx为源参考,切割slice_body.xlsx

![slice_body](https://github.com/misuqian/ExcelTool/blob/master/png/slice_body.png) __+__
![slice_refer](https://github.com/misuqian/ExcelTool/blob/master/png/slice_refer.png) __=__
![slice_result01](https://github.com/misuqian/ExcelTool/blob/master/png/slice_result01.png)

__or =__
![slice_result02](https://github.com/misuqian/ExcelTool/blob/master/png/slice_result02.png)

__你只需要根据界面简单设置__
[slice_config](https://github.com/misuqian/ExcelTool/blob/master/png/slice_config01.png)

__需要切割到不同文件在这里选择即可__
![slice_config2](https://github.com/misuqian/ExcelTool/blob/master/png/slice_config02.png)

##高级拼接 Advanced Paste
进行文件拼接时,忽略某些行(或者列)不进行拼接

![paset01](https://github.com/misuqian/ExcelTool/blob/master/png/paste_advance01.png) **+**
![paset02](https://github.com/misuqian/ExcelTool/blob/master/png/paste_advance02.png) __=__
![paset_result](https://github.com/misuqian/ExcelTool/blob/master/png/paste_advance_result.png)

__在对应文件导入窗口设置忽略行数(或列数即可)__
![paste_config](https://github.com/misuqian/ExcelTool/blob/master/png/paste_advance_config02.png)

##高级分割 Advanced Slice
将某些行自动保存到所有的分割文件中,并且以自己为源文件进行切割

![slice_body](https://github.com/misuqian/ExcelTool/blob/master/png/paste_advance_result.png) __+__
![slice_refer](https://github.com/misuqian/ExcelTool/blob/master/png/paste_advance_result.png) __=__
![slice_result01](https://github.com/misuqian/ExcelTool/blob/master/png/slice_advance_result.png)

__通过设置忽略行以及参考自己本身即可__
![slice_config](https://github.com/misuqian/ExcelTool/blob/master/png/slice_advance_config.png)


text:
int qtc_QBoxLayout_unSetHandler(void*,void*);
void qtc_QBoxLayout_addItem_h(void*,void*);
int qtc_QBoxLayout_setHandler1(void*,void*,void*,void*,void*);
int qtc_QBoxLayout_count_h(void*);
int qtc_QBoxLayout_setHandler2(void*,void*,void*,void*,void*);
long qtc_QBoxLayout_expandingDirections_h(void*);
int qtc_QBoxLayout_setHandler3(void*,void*,void*,void*,void*);
int qtc_QBoxLayout_hasHeightForWidth_h(void*);
int qtc_QBoxLayout_setHandler4(void*,void*,void*,void*,void*);
int qtc_QBoxLayout_heightForWidth_h(void*,int);
int qtc_QBoxLayout_setHandler5(void*,void*,void*,void*,void*);
void qtc_QBoxLayout_invalidate_h(void*);
int qtc_QBoxLayout_setHandler6(void*,void*,void*,void*,void*);
void* qtc_QBoxLayout_itemAt_h(void*,int);
int qtc_QBoxLayout_setHandler7(void*,void*,void*,void*,void*);
void* qtc_QBoxLayout_maximumSize_h(void*);
int qtc_QBoxLayout_setHandler8(void*,void*,void*,void*,void*);
void* qtc_QBoxLayout_maximumSize_qth_h(void*,int*,int*);
int qtc_QBoxLayout_minimumHeightForWidth_h(void*,int);
void* qtc_QBoxLayout_minimumSize_h(void*);
void* qtc_QBoxLayout_minimumSize_qth_h(void*,int*,int*);
void qtc_QBoxLayout_setGeometry_h(void*,void*);
int qtc_QBoxLayout_setHandler9(void*,void*,void*,void*,void*);
void qtc_QBoxLayout_setGeometry_qth_h(void*, int, int, int, int);
void* qtc_QBoxLayout_sizeHint_h(void*);
void* qtc_QBoxLayout_sizeHint_qth_h(void*,int*,int*);
void* qtc_QBoxLayout_takeAt_h(void*,int);
int qtc_QBoxLayout_indexOf_h(void*,void*);
int qtc_QBoxLayout_setHandler10(void*,void*,void*,void*,void*);
int qtc_QBoxLayout_isEmpty_h(void*);
void* qtc_QBoxLayout_layout_h(void*);
int qtc_QBoxLayout_setHandler11(void*,void*,void*,void*,void*);
void* qtc_QBoxLayout_geometry_h(void*);
int qtc_QBoxLayout_setHandler12(void*,void*,void*,void*,void*);
void* qtc_QBoxLayout_geometry_qth_h(void*,int*,int*,int*,int*);
void* qtc_QBoxLayout_spacerItem_h(void*);
int qtc_QBoxLayout_setHandler13(void*,void*,void*,void*,void*);
void* qtc_QBoxLayout_widget_h(void*);
int qtc_QBoxLayout_event_h(void*,void*);
int qtc_QBoxLayout_setHandler14(void*,void*,void*,void*,void*);
int qtc_QBoxLayout_eventFilter_h(void*,void*,void*);
int qtc_QBoxLayout_setHandler15(void*,void*,void*,void*,void*);


text:
namespace mcpack2pb {

const char* type2str(FieldType type) {
    bool is_short = false;
    if (type & FIELD_SHORT_MASK) {
        is_short = true;
        type = (FieldType)(type & ~FIELD_SHORT_MASK);
    }
    switch (type) {
    case FIELD_OBJECT:         return "object";
    case FIELD_ARRAY:          return "array";
    case FIELD_ISOARRAY:       return "isoarray";
    case FIELD_OBJECTISOARRAY: return "object_isoarray";
    case FIELD_STRING:         return (is_short ? "string(short)" : "string");
    case FIELD_BINARY:         return (is_short ? "binary(short)" : "binary");
    case FIELD_INT8:          return "int8";
    case FIELD_INT16:         return "int16";
    case FIELD_INT32:         return "int32";
    case FIELD_INT64:         return "int64";
    case FIELD_UINT8:         return "uint8";
    case FIELD_UINT16:        return "uint16";
    case FIELD_UINT32:        return "uint32";
    case FIELD_UINT64:        return "uint64";
    case FIELD_BOOL:           return "bool";
    case FIELD_FLOAT:          return "float";
    case FIELD_DOUBLE:         return "double";
    case FIELD_DATE:           return "date";
    case FIELD_NULL:           return "null";
    }
    return "unknown_field_type";
}

} // namespace mcpack2pb


text:
<?php
namespace Titon\Db\Query;

use Titon\Test\TestCase;

/**
 * @property \Titon\Db\Query\Join $object
 */
class JoinTest extends TestCase {

    protected function setUp() {
        parent::setUp();

        $this->object = new Join(Join::LEFT);
    }

    public function testFrom() {
        $this->object->from('users');
        $this->assertEquals('users', $this->object->getTable());
    }

    public function testAlias() {
        $this->object->asAlias('U');
        $this->assertEquals('U', $this->object->getAlias());
    }

    public function testType() {
        $this->assertEquals(Join::LEFT, $this->object->getType());
    }

    public function testFields() {
        $this->object->fields('id', 'username');
        $this->assertEquals(['id', 'username'], $this->object->getFields());

        $this->object->fields(['id', 'user']);
        $this->assertEquals(['id', 'user'], $this->object->getFields());

        $this->object->fields(['user' => 'foo']);
        $this->assertEquals(['user' => 'foo'], $this->object->getFields());
    }

    public function testOn() {
        $this->object->on('id', 'id');
        $this->assertEquals(['id' => 'id'], $this->object->getOn());

        $this->object->on(['users.id' => 'profiles.id', 'id' => 'new_id']);
        $this->assertEquals(['id' => 'new_id', 'users.id' => 'profiles.id'], $this->object->getOn());
    }

}


text:
using System;
using BinaryBitmap = com.google.zxing.BinaryBitmap;
using DecodeHintType = com.google.zxing.DecodeHintType;
using Reader = com.google.zxing.Reader;
using ReaderException = com.google.zxing.ReaderException;
using Result = com.google.zxing.Result;
using ResultMetadataType = com.google.zxing.ResultMetadataType;
using ResultPoint = com.google.zxing.ResultPoint;
using BitArray = com.google.zxing.common.BitArray;
namespace com.google.zxing.oned
{

	///  Encapsulates functionality and implementation that is common to all families
	/// of one-dimensional barcodes.
	///
	///
	/// <author>  dswitkin@google.com (Daniel Switkin)
	/// </author>
	/// <author>  Sean Owen
	/// </author>
	/// <author>www.Redivivus.in (suraj.supekar@redivivus.in) - Ported from ZXING Java Source
	/// </author>
	public abstract class OneDReader : Reader
	{

		private const int INTEGER_MATH_SHIFT = 8;
		//UPGRADE_NOTE: Final was removed from the declaration of 'PATTERN_MATCH_RESULT_SCALE_FACTOR '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
		internal static readonly int PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 << INTEGER_MATH_SHIFT;

		public virtual Result decode(BinaryBitmap image)
		{
			return decode(image, null);
		}

		// Note that we don't try rotation without the try harder flag, even if rotation was supported.
		public virtual Result decode(BinaryBitmap image, System.Collections.Hashtable hints)
		{
			try
			{
				return doDecode(image, hints);
			}
			catch (ReaderException re)
			{
				bool tryHarder = hints != null && hints.ContainsKey(DecodeHintType.TRY_HARDER);
				if (tryHarder && image.RotateSupported)
				{
					BinaryBitmap rotatedImage = image.rotateCounterClockwise();
					Result result = doDecode(rotatedImage, hints);
					// Record that we found it rotated 90 degrees CCW / 270 degrees CW
					System.Collections.Hashtable metadata = result.ResultMetadata;
					int orientation = 270;
					if (metadata != null && metadata.ContainsKey(ResultMetadataType.ORIENTATION))
					{
						// But if we found it reversed in doDecode(), add in that result here:
						orientation = (orientation + ((System.Int32) metadata[ResultMetadataType.ORIENTATION])) % 360;
					}
					result.putMetadata(ResultMetadataType.ORIENTATION, (System.Object) orientation);
					// Update result points
					ResultPoint[] points = result.ResultPoints;
					int height = rotatedImage.Height;
					for (int i = 0; i < points.Length; i++)
					{
						points[i] = new ResultPoint(height - points[i].Y - 1, points[i].X);
					}
					return result;
				}
				else
				{
					throw re;
				}
			}
		}

		///  We're going to examine rows from the middle outward, searching alternately above and below the
		/// middle, and farther out each time. rowStep is the number of rows between each successive
		/// attempt above and below the middle. So we'd scan row middle, then middle - rowStep, then
		/// middle + rowStep, then middle - (2 * rowStep), etc.
		/// rowStep is bigger as the image is taller, but is always at least 1. We've somewhat arbitrarily
		/// decided that moving up and down by about 1/16 of the image is pretty good; we try more of the
		/// image if "trying harder".
		///
		///
		/// <param name="image">The image to decode
		/// </param>
		/// <param name="hints">Any hints that were requested
		/// </param>
		/// <returns> The contents of the decoded barcode
		/// </returns>
		/// <throws>  ReaderException Any spontaneous errors which occur </throws>
		private Result doDecode(BinaryBitmap image, System.Collections.Hashtable hints)
		{
			int width = image.Width;
			int height = image.Height;
			BitArray row = new BitArray(width);

			int middle = height >> 1;
			bool tryHarder = hints != null && hints.ContainsKey(DecodeHintType.TRY_HARDER);
			int rowStep = System.Math.Max(1, height >> (tryHarder?7:4));
			int maxLines;
			if (tryHarder)
			{
				maxLines = height; // Look at the whole image, not just the center
			}
			else
			{
				maxLines = 9; // Nine rows spaced 1/16 apart is roughly the middle half of the image
			}

			for (int x = 0; x < maxLines; x++)
			{

				// Scanning from the middle out. Determine which row we're looking at next:
				int rowStepsAboveOrBelow = (x + 1) >> 1;
				bool isAbove = (x & 0x01) == 0; // i.e. is x even?
				int rowNumber = middle + rowStep * (isAbove?rowStepsAboveOrBelow:- rowStepsAboveOrBelow);
				if (rowNumber < 0 || rowNumber >= height)
				{
					// Oops, if we run off the top or bottom, stop
					break;
				}

				// Estimate black point for this row and load it:
				try
				{
					row = image.getBlackRow(rowNumber, row);
				}
				catch (ReaderException)
				{
					continue;
				}

				// While we have the image data in a BitArray, it's fairly cheap to reverse it in place to
				// handle decoding upside down barcodes.
				for (int attempt = 0; attempt < 2; attempt++)
				{
					if (attempt == 1)
					{
						// trying again?
						row.reverse(); // reverse the row and continue
						// This means we will only ever draw result points *once* in the life of this method
						// since we want to avoid drawing the wrong points after flipping the row, and,
						// don't want to clutter with noise from every single row scan -- just the scans
						// that start on the center line.
						if (hints != null && hints.ContainsKey(DecodeHintType.NEED_RESULT_POINT_CALLBACK))
						{
							System.Collections.Hashtable newHints = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable()); // Can't use clone() in J2ME
							System.Collections.IEnumerator hintEnum = hints.Keys.GetEnumerator();
							//UPGRADE_TODO: Method 'java.util.Enumeration.hasMoreElements' was converted to 'System.Collections.IEnumerator.MoveNext' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilEnumerationhasMoreElements'"
							while (hintEnum.MoveNext())
							{
								//UPGRADE_TODO: Method 'java.util.Enumeration.nextElement' was converted to 'System.Collections.IEnumerator.Current' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilEnumerationnextElement'"
								System.Object key = hintEnum.Current;
								if (!key.Equals(DecodeHintType.NEED_RESULT_POINT_CALLBACK))
								{
									newHints[key] = hints[key];
								}
							}
							hints = newHints;
						}
					}
					try
					{
						// Look for a barcode
						Result result = decodeRow(rowNumber, row, hints);
						// We found our barcode
						if (attempt == 1)
						{
							// But it was upside down, so note that
							result.putMetadata(ResultMetadataType.ORIENTATION, (System.Object) 180);
							// And remember to flip the result points horizontally.
							ResultPoint[] points = result.ResultPoints;
							points[0] = new ResultPoint(width - points[0].X - 1, points[0].Y);
							points[1] = new ResultPoint(width - points[1].X - 1, points[1].Y);
						}
						return result;
					}
					catch (ReaderException)
					{
						// continue -- just couldn't decode this row
					}
				}
			}

			throw ReaderException.Instance;
		}

		///  Records the size of successive runs of white and black pixels in a row, starting at a given point.
		/// The values are recorded in the given array, and the number of runs recorded is equal to the size
		/// of the array. If the row starts on a white pixel at the given start point, then the first count
		/// recorded is the run of white pixels starting from that point; likewise it is the count of a run
		/// of black pixels if the row begin on a black pixels at that point.
		///
		///
		/// <param name="row">row to count from
		/// </param>
		/// <param name="start">offset into row to start at
		/// </param>
		/// <param name="counters">array into which to record counts
		/// </param>
		/// <throws>  ReaderException if counters cannot be filled entirely from row before running out </throws>
		///   of pixels
		///
		internal static void  recordPattern(BitArray row, int start, int[] counters)
		{
			int numCounters = counters.Length;
			for (int i = 0; i < numCounters; i++)
			{
				counters[i] = 0;
			}
			int end = row.Size;
			if (start >= end)
			{
				throw ReaderException.Instance;
			}
			bool isWhite = !row.get_Renamed(start);
			int counterPosition = 0;
			int i2 = start;
			while (i2 < end)
			{
				bool pixel = row.get_Renamed(i2);
				if (pixel ^ isWhite)
				{
					// that is, exactly one is true
					counters[counterPosition]++;
				}
				else
				{
					counterPosition++;
					if (counterPosition == numCounters)
					{
						break;
					}
					else
					{
						counters[counterPosition] = 1;
						isWhite ^= true; // isWhite = !isWhite;
					}
				}
				i2++;
			}
			// If we read fully the last section of pixels and filled up our counters -- or filled
			// the last counter but ran off the side of the image, OK. Otherwise, a problem.
			if (!(counterPosition == numCounters || (counterPosition == numCounters - 1 && i2 == end)))
			{
				throw ReaderException.Instance;
			}
		}

		///  Determines how closely a set of observed counts of runs of black/white values matches a given
		/// target pattern. This is reported as the ratio of the total variance from the expected pattern
		/// proportions across all pattern elements, to the length of the pattern.
		///
		///
		/// <param name="counters">observed counters
		/// </param>
		/// <param name="pattern">expected pattern
		/// </param>
		/// <param name="maxIndividualVariance">The most any counter can differ before we give up
		/// </param>
		/// <returns> ratio of total variance between counters and pattern compared to total pattern size,
		/// where the ratio has been multiplied by 256. So, 0 means no variance (perfect match); 256 means
		/// the total variance between counters and patterns equals the pattern length, higher values mean
		/// even more variance
		/// </returns>
		internal static int patternMatchVariance(int[] counters, int[] pattern, int maxIndividualVariance)
		{
			int numCounters = counters.Length;
			int total = 0;
			int patternLength = 0;
			for (int i = 0; i < numCounters; i++)
			{
				total += counters[i];
				patternLength += pattern[i];
			}
			if (total < patternLength)
			{
				// If we don't even have one pixel per unit of bar width, assume this is too small
				// to reliably match, so fail:
				return System.Int32.MaxValue;
			}
			// We're going to fake floating-point math in integers. We just need to use more bits.
			// Scale up patternLength so that intermediate values below like scaledCounter will have
			// more "significant digits"
			int unitBarWidth = (total << INTEGER_MATH_SHIFT) / patternLength;
			maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> INTEGER_MATH_SHIFT;

			int totalVariance = 0;
			for (int x = 0; x < numCounters; x++)
			{
				int counter = counters[x] << INTEGER_MATH_SHIFT;
				int scaledPattern = pattern[x] * unitBarWidth;
				int variance = counter > scaledPattern?counter - scaledPattern:scaledPattern - counter;
				if (variance > maxIndividualVariance)
				{
					return System.Int32.MaxValue;
				}
				totalVariance += variance;
			}
			return totalVariance / total;
		}

		///
Attempts to decode a one-dimensional barcode format given a single row of
		/// an image.

		///
		///
		/// <param name="rowNumber">row number from top of the row
		/// </param>
		/// <param name="row">the black/white pixel data of the row
		/// </param>
		/// <param name="hints">decode hints
		/// </param>
		/// <returns> {@link Result} containing encoded string and start/end of barcode
		/// </returns>
		/// <throws>  ReaderException if an error occurs or barcode cannot be found </throws>
		public abstract Result decodeRow(int rowNumber, BitArray row, System.Collections.Hashtable hints);
	}
}


text:
const webpack = require('webpack');
const WebpackDevServer = require('webpack-dev-server');
const webpackConfig = require('./webpack.config');

webpackConfig.output.publicPath = `http://localhost:3000${webpackConfig.output.publicPath}`;

const compiler = webpack(webpackConfig);
const server = new WebpackDevServer(compiler, {
  inline: true,
  hot: true,
  historyApiFallback: true,
  contentBase: './'
});
server.listen(3000, 'localhost', function() { console.info('Webpack dev server started at http://localhost:3000') });


text:
<?xml version="1.0" encoding="utf-8"?>
<doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping http://doctrine-project.org/schemas/orm/doctrine-mapping.xsd">
  <entity name="Multiservices\InventarioBundle\Entity\Impuestos" table="impuestos">
    <id name="codimpuesto" type="integer" column="codimpuesto">
      <generator strategy="IDENTITY"/>
    </id>
    <field name="nombre" type="string" column="nombre" length="20" nullable="true"/>
    <field name="valor" type="float" column="valor" precision="10" scale="0" nullable="false"/>
    <field name="borrado" type="string" column="borrado" length="1" nullable="false"/>
  </entity>
</doctrine-mapping>


text:
package store

import (
	//"fmt"
	"io"
	"os"
)

type SectionReader interface {
	io.Reader
	io.ReaderAt
}

type ReaderAt interface {
	io.Reader
	io.ReaderAt
	Stat() (os.FileInfo, error)
}

type multiReaderAt struct {
	readers    []ReaderAt
	boundaries []multifd
	size       int64
}

type multifd struct {
	start int64
	end   int64
	size  int64
}

func (mr *multiReaderAt) Read(p []byte) (n int, err error) {
	for len(mr.readers) > 0 {
		n, err = mr.readers[0].Read(p)
		if n > 0 || err != io.EOF {
			if err == io.EOF {
				// Don't return EOF yet. There may be more bytes
				// in the remaining readers.
				err = nil
			}
			return
		}
		mr.readers = mr.readers[1:]
	}
	return 0, io.EOF
}

func (mr *multiReaderAt) ReadAt(p []byte, off int64) (n int, err error) {
	startF, endF := 0, 0
	startPos, endPos, length := int64(0), int64(0), int64(len(p))

	if off > mr.size {
		return 0, io.EOF
	}

	// find start
	for i, fd := range mr.boundaries {
		if off >= fd.start && off <= fd.end {
			startF = i
			startPos = off - fd.start
			break
		}
	}

	// find end
	if off+length > mr.size {
		endF = len(mr.readers) - 1
		endPos = mr.size - mr.boundaries[endF].start
	} else {
		for i, fd := range mr.boundaries {
			if off+length >= fd.start && off+length <= fd.end {
				endF = i
				endPos = off + length - fd.start
				break
			}
		}
	}

	if startF == endF {
		// read startpos till endpos
		// println("--> readat: startpos till endpos")
		// fmt.Printf("file: %d, offset: %d, length: %d\n", startF, startPos, endPos-startPos)
		return mr.readers[startF].ReadAt(p[0:length], startPos)
	} else {
		buffPos := 0
		for i := startF; i <= endF; i++ {
			if i == startF {
				// read startpos till end of file
				// println("--> readat: startpos till end of file")
				// fmt.Printf("file: %d, offset: %d, length: %d, buffPos: %d\n", i, startPos, mr.boundaries[i].size-startPos, buffPos)
				if rn, err := mr.readers[i].ReadAt(p[buffPos:buffPos+int(mr.boundaries[i].size-startPos)], startPos); err != nil && err != io.EOF {
					return 0, err
				} else {
					buffPos = buffPos + int(mr.boundaries[i].size-startPos)
					n = n + rn
				}
			} else if i == endF {
				// read start of file till endpos
				// println("--> readat: start of file till endpos")
				// fmt.Printf("file: %d, offset: %d, length: %d, buffPos: %d\n", i, 0, endPos, buffPos)
				if rn, err := mr.readers[i].ReadAt(p[buffPos:buffPos+int(endPos)], 0); err != nil && err != io.EOF {
					println("--> error here: ", err.Error())
					return 0, err
				} else {
					buffPos = buffPos + int(endPos)
					n = n + rn
				}
			} else {
				// read entire file
				// println("--> readat: entire file")
				// fmt.Printf("file: %d, offset: %d, length: %d, buffPos: %d\n", i, 0, mr.boundaries[i].size, buffPos)
				if rn, err := mr.readers[i].ReadAt(p[buffPos:buffPos+int(mr.boundaries[i].size)], 0); err != nil && err != io.EOF {
					return 0, err
				} else {
					buffPos = buffPos + int(mr.boundaries[i].size)
					n = n + rn
				}
			}
		}
	}
	if n < int(length) {
		return n, io.EOF
	}
	return
}

// do not use
func (mr *multiReaderAt) Stat() (fi os.FileInfo, err error) {
	return
}

// MultiReader returns a Reader that's the logical concatenation of
// the provided input readers.  They're read sequentially.  Once all
// inputs are drained, Read will return EOF.
func MultiReaderAt(readers ...ReaderAt) ReaderAt {
	mr := &multiReaderAt{readers: readers}
	b := []multifd{}
	start := int64(0)
	for _, r := range mr.readers {
		fi, _ := r.Stat()
		b = append(b, multifd{start: start, end: start + fi.Size(), size: fi.Size()})
		start = start + fi.Size()
	}
	mr.boundaries = b
	mr.size = b[len(b)-1].end
	return mr
}


text:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Settings>
    <settings>
        <entry xsi:type="myHashMapEntryTypeHashMap" key="Physics" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
            <value>
                <entry xsi:type="myHashMapEntryTypeObject" key="speed">
                    <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">1.0</value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeObject" key="debug">
                    <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeObject" key="framerate">
                    <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">60</value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeObject" key="maxsubsteps">
                    <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">32</value>
                </entry>
				<entry xsi:type="myHashMapEntryTypeObject" key="poke">
                    <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">5.0</value>
                </entry>
            </value>
        </entry>
        <entry xsi:type="myHashMapEntryTypeHashMap" key="Misc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
            <value>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Camera">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="FlyCamMoveSpeed">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">30</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="ChaseCamZoomSensitivity">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.5</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeVector3F" key="DefaultPosition">
                            <value>
                                <x>15.0</x>
                                <y>10.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeVector3F" key="DefaultRotation">
                            <value>
                                <x>0.0</x>
                                <y>0.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Record">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                    </value>
                </entry>
				<entry xsi:type="myHashMapEntryTypeHashMap" key="Logging">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="level">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">ALL</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="fileWrite">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                    </value>
                </entry>
				<entry xsi:type="myHashMapEntryTypeObject" key="headless">
                    <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                </entry>
            </value>
        </entry>
        <entry xsi:type="myHashMapEntryTypeHashMap" key="Gui" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
            <value>
                <entry xsi:type="myHashMapEntryTypeColorRGBA" key="collisionColor">
                    <value>
                        1.0
                        0.0
                        <g>0.0</g>
                        <r>1.0</r>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeColorRGBA" key="selectionColor">
                    <value>
                        1.0
                        0.0
                        <g>0.843</g>
                        <r>1.0</r>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeObject" key="GlowSelection">
                    <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeObject" key="AmbientSelection">
                    <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                </entry>
				<entry xsi:type="myHashMapEntryTypeObject" key="PopUpAUVName">
                    <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                </entry>
				<entry xsi:type="myHashMapEntryTypeObject" key="PopUpAUVNameDistance">
                    <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">30.0</value>
                </entry>
				<entry xsi:type="myHashMapEntryTypeObject" key="MouseUpdateFollow">
                    <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                </entry>
            </value>
        </entry>
        <entry xsi:type="myHashMapEntryTypeHashMap" key="Graphics" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
            <value>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Flow">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="forceScale">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">20.0</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="MapX">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">flow_x.png</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="position">
                            <value>
                                <x>-7.0</x>
                                <y>-2.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="scale">
                            <value>
                                <x>0.15625</x>
                                <y>0.01176</y>
                                <z>0.15625</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="MapY">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">flow_y.png</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="rotation">
                            <value>
                                <x>0.0</x>
                                <y>0.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                    </value>
                </entry>
				<entry xsi:type="myHashMapEntryTypeHashMap" key="Pollution">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="scaleFactor">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">20.0</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="pollutionMap">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">neustadt_pm.png</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="position">
                            <value>
                                <x>-7.0</x>
                                <y>-2.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="scale">
                            <value>
                                <x>2.66666</x>
                                <y>0.01176</y>
                                <z>2.66666</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="visible">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="detectable">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="rotation">
                            <value>
                                <x>0.0</x>
                                <y>0.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Axis">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="SkyBox">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="filepath">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">skytest.dds</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Resolution">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="height">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">480</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="width">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">640</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="SkyDome">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="speed">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">100.0</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="direction">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">1.0</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="cloudiness">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.5</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="cloudRate">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">1.0</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="cloudModulation">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="hour">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">5.7</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="observerLatitude">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.8932385672196739</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="lunarDiameter">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.0092</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="solarLongitude">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.0</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="lunarPhase">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">0</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="PlaneWater">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="filepath">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">water_2.png</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="WireFrame">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeColorRGBA" key="color">
                            <value>
                                0.0
                                0.0
                                <g>0.0</g>
                                <r>1.0</r>
                            </value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Shadow">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Grass">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="DensityMap">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">wakenitz_am.png</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="farViewingDistance">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">50.0</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="farViewingDistanceImposter">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">70.0</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="plantingRandomness">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.3</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="patchSize">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">4</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="SimpleSkyBox">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeColorRGBA" key="color">
                            <value>
                                0.0
                                0.99607843
                                <g>0.8</g>
                                <r>0.45490196</r>
                            </value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeObject" key="FrameLimit">
                    <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">60</value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Fog">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeColorRGBA" key="color">
                            <value>
                                1.0
                                0.9411765
                                <g>0.4745098</g>
                                <r>0.05882353</r>
                            </value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Water">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="DepthOfField">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="FocusRange">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">5.0</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="BlurScale">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">2.5</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Density">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">4.0</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Distance">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">90.0</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="FocusDistance">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">5.0</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="FPS">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Grid">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="position">
                            <value>
                                <x>0.0</x>
                                <y>0.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="SizeX">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">100</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeColorRGBA" key="color">
                            <value>
                                0.0
                                1.0
                                <g>1.0</g>
                                <r>1.0</r>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="rotation">
                            <value>
                                <x>0.0</x>
                                <y>0.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="SizeY">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">100</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="LineDistance">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">1.0</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="ProjectedWavesWater">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Scalexsmall">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.04</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Speedbig">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.5</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Scaleybig">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.1</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Heightsmall">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.25</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Scaleysmall">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.02</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Heightbig">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.01</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Scalexbig">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">0.03</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Speedsmall">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">1.0</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="Octaves">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">0</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Light">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeColorRGBA" key="color">
                            <value>
                                0.8
                                1.0
                                <g>1.0</g>
                                <r>1.0</r>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeColorRGBA" key="ambientColor">
                            <value>
                                0.2
                                1.0
                                <g>1.0</g>
                                <r>1.0</r>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="direction">
                            <value>
                                <x>0.0</x>
                                <y>-1.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="ambient">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="CrossHairs">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="WavesWater">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="Terrain">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="position">
                            <value>
                                <x>-7.0</x>
                                <y>-2.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="scale">
                            <value>
                                <x>2.66666</x>
                                <y>0.01676</y>
                                <z>2.66666</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeVector3F" key="rotation">
                            <value>
                                <x>0.0</x>
                                <y>0.0</y>
                                <z>0.0</z>
                            </value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="lod">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="LodMultiplier">
                            <value xsi:type="xs:float" xmlns:xs="http://www.w3.org/2001/XMLSchema">2.7</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="HeightMap">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">neustadt_hm.png</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="ColorMap">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">neustadt_cm.png</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="AlphaMap">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">wakenitz_2_am.png</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="patchSize">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">32</value>
                        </entry>
                    </value>
                </entry>
            </value>
        </entry>
        <entry xsi:type="myHashMapEntryTypeHashMap" key="Server" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
            <value>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="RAW">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="port">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">8080</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="OutputStreamSize">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">1228100</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="backlog">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">10</value>
                        </entry>
                    </value>
                </entry>
                <entry xsi:type="myHashMapEntryTypeHashMap" key="ROS">
                    <value>
                        <entry xsi:type="myHashMapEntryTypeObject" key="enabled">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">false</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="localip">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">141.83.88.159</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="masterip">
                            <value xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema">141.83.88.157</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="publish">
                            <value xsi:type="xs:boolean" xmlns:xs="http://www.w3.org/2001/XMLSchema">true</value>
                        </entry>
                        <entry xsi:type="myHashMapEntryTypeObject" key="masterport">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">11311</value>
                        </entry>
						<entry xsi:type="myHashMapEntryTypeObject" key="GlobalQueueSize">
                            <value xsi:type="xs:int" xmlns:xs="http://www.w3.org/2001/XMLSchema">10</value>
                        </entry>
                    </value>
                </entry>
            </value>
        </entry>
    </settings>
</Settings>


text:
package jsky.util.gui;

public interface TextBoxWidgetWatcher {
    default void textBoxKeyPress(TextBoxWidget tbwe) {}
    default void textBoxAction(TextBoxWidget tbwe) {}
    default void textBoxDoneEditing(TextBoxWidget tbwe) {}
}


text:
using Owin;
using System.Web.Http;

namespace ConsoleServer
{
    public class Startup
    {
        // This code configures Web API. The Startup class is specified as a type
        // parameter in the WebApp.Start method.
        public void Configuration(IAppBuilder appBuilder)
        {
            // Configure Web API for self-host.
            var config = new HttpConfiguration();

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            appBuilder.Use((context,next) =>
            {
                context.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); // alt: http://localhost:14054
                return next.Invoke();
            });

            appBuilder.UseWebApi(config);
        }
    }

}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Anal. Mus. nac. B. Aires, Ser. 3 19(12): 364 (1909)

#### Original name
Diaporthe solani-verbascifolii Speg.

### Remarks
null


text:
Pivotal Tracker Subtotals
=================

Small Google Chrome Extension, that shows pivotal subtotals on the time shifts page

=====

=====
Clone this project

[Setup extension from the source](https://developer.chrome.com/extensions/getstarted#unpacked)


text:
<?php

/**
 * This code was generated by
 * \ / _    _  _|   _  _
 * | (_)\/(_)(_|\/| |(/_  v1.0.0
 * /       /
 */

namespace Twilio\Rest\Supersim\V1\NetworkAccessProfile;

use Twilio\Exceptions\TwilioException;
use Twilio\InstanceResource;
use Twilio\Values;
use Twilio\Version;

/**
 * PLEASE NOTE that this class contains beta products that are subject to change. Use them with caution.
 *
 * @property string $sid
 * @property string $networkAccessProfileSid
 * @property string $friendlyName
 * @property string $isoCountry
 * @property array[] $identifiers
 * @property string $url
 */
class NetworkAccessProfileNetworkInstance extends InstanceResource {
    /**
     * Initialize the NetworkAccessProfileNetworkInstance
     *
     * @param Version $version Version that contains the resource
     * @param mixed[] $payload The response payload
     * @param string $networkAccessProfileSid The unique string that identifies the
     *                                        Network Access Profile resource
     * @param string $sid The SID of the resource to fetch
     */
    public function __construct(Version $version, array $payload, string $networkAccessProfileSid, string $sid = null) {
        parent::__construct($version);

        // Marshaled Properties
        $this->properties = [
            'sid' => Values::array_get($payload, 'sid'),
            'networkAccessProfileSid' => Values::array_get($payload, 'network_access_profile_sid'),
            'friendlyName' => Values::array_get($payload, 'friendly_name'),
            'isoCountry' => Values::array_get($payload, 'iso_country'),
            'identifiers' => Values::array_get($payload, 'identifiers'),
            'url' => Values::array_get($payload, 'url'),
        ];

        $this->solution = [
            'networkAccessProfileSid' => $networkAccessProfileSid,
            'sid' => $sid ?: $this->properties['sid'],
        ];
    }

    /**
     * Generate an instance context for the instance, the context is capable of
     * performing various actions.  All instance actions are proxied to the context
     *
     * @return NetworkAccessProfileNetworkContext Context for this
     *                                            NetworkAccessProfileNetworkInstance
     */
    protected function proxy(): NetworkAccessProfileNetworkContext {
        if (!$this->context) {
            $this->context = new NetworkAccessProfileNetworkContext(
                $this->version,
                $this->solution['networkAccessProfileSid'],
                $this->solution['sid']
            );
        }

        return $this->context;
    }

    /**
     * Delete the NetworkAccessProfileNetworkInstance
     *
     * @return bool True if delete succeeds, false otherwise
     * @throws TwilioException When an HTTP error occurs.
     */
    public function delete(): bool {
        return $this->proxy()->delete();
    }

    /**
     * Fetch the NetworkAccessProfileNetworkInstance
     *
     * @return NetworkAccessProfileNetworkInstance Fetched
     *                                             NetworkAccessProfileNetworkInstance
     * @throws TwilioException When an HTTP error occurs.
     */
    public function fetch(): NetworkAccessProfileNetworkInstance {
        return $this->proxy()->fetch();
    }

    /**
     * Magic getter to access properties
     *
     * @param string $name Property to access
     * @return mixed The requested property
     * @throws TwilioException For unknown properties
     */
    public function __get(string $name) {
        if (\array_key_exists($name, $this->properties)) {
            return $this->properties[$name];
        }

        if (\property_exists($this, '_' . $name)) {
            $method = 'get' . \ucfirst($name);
            return $this->$method();
        }

        throw new TwilioException('Unknown property: ' . $name);
    }

    /**
     * Provide a friendly representation
     *
     * @return string Machine friendly representation
     */
    public function __toString(): string {
        $context = [];
        foreach ($this->solution as $key => $value) {
            $context[] = "$key=$value";
        }
        return '[Twilio.Supersim.V1.NetworkAccessProfileNetworkInstance ' . \implode(' ', $context) . ']';
    }
}


text:
package common;

import main.SlackBot;

/**
 * @author atomicfruitcake
 *
 */
public class Properties {

    // Default settings
    public static final String DEFAULT_SETTINGS = "IAT \n"
	    + "Setting 1"
	    + "Setting 2";
    public static final String SETTINGS_FILE = "settings.txt";
    public static final String SLACK_BOT_TOKEN = "";
    public static final String SLACK_BOT_ID = "";
	public static final String SLACK_BOT_NAME = "";
    public static final String[] SLACK_BOT_CONFIRMATION = new String[] {
	    "Sure thing, ", "I'm on it, ", "No problem, " };
    public static final String[] SLACK_BOT_ERROR = new String[] {
	    "I'm sorry, I don't understand that, try _idbot help_",
	    "I don't get that. Maybe try _idbot help_",
	    "I'm sorry I haven't a clue. Try _idbot help_ ",
	    "¯\\_(ツ)_/¯ try _idbot help_"};
    public static final String SLACK_BOT_HELP = "I'm happy to hello \n"
	    + "Currently, I only understand the following commands: \n"
	    + "_hi_ \n"
	    + "_call_ \n"
	    + "_foo_ \n"
	    + "_reset_ \n"
	    + "_resethard_ \n"
	    + "\n "
	    + "There may be some secret commands, but you're not getting them that easy";
    public static final String[] SLACK_BOT_JOKES = new String[] {
	    SlackBot.slackUser.getUserName(),
	    "Stationary store moves",
	    "If at first you don't succeed; call it version 1.0.",
	    "If you want your software to be bug free, let it just develop, unexpected random features",
	    "Latest survey shows that 3 out of 4 people make up 75% of the world's population",
	    "Endless Loop: n., see Loop, Endless. Loop, Endless: n., see Endless Loop.",
	    "Just read that 4,153,237 people got married last year, not to cause any trouble but shouldn't that be an even number?",
	    "Life is all about perspective. The sinking of the Titanic was a miracle to the lobsters in the ship's kitchen.",
	    "Strong people don't put others down. They lift them up and slam them on the ground for maximum damage.",
	    "If you think nobody cares whether you're alive, try missing a couple of rent payments." };

    public static final String[] SLACK_BOT_STATUS = new String[] {
	    "*Request URL:* http://idbot/lovelife \n"
		    + "*Request methods:* GET \n"
		    + "*Status Code:* 404 Not Found",
	    "*Request URL:* http://idbot/emotion \n"
		    + "*Request methods:* GET \n"
		    + "*Status Code:* 500 internal server error",
	    "*Request URL:* http://idbot/action/kill/humans \n"
		    + "*Request methods:* GET \n"
		    + "*Status Code:* 403 forbidden", };
    public static final String CHUCK_NORRIS_JOKE_API = "https://api.icndb.com/jokes/random";
}