text:
hosts_dir="/tmp/hosts.$(date +%s | md5 | base64 | head -c 32; echo)"
git clone https://github.com/StevenBlack/hosts $hosts_dir

# Link domain lists from dotfiles
[ -f "$DOTFILES/blacklist" ] && ln -fs $DOTFILES/blacklist $hosts_dir/blacklist
[ -f "$DOTFILES/whitelist" ] && ln -fs $DOTFILES/whitelist $hosts_dir/whitelist

# Link domain list from args, ./hosts.sh ../foo/myhosts
if [ -n "$1" ]; then
  cd $(dirname $1)
  myhosts=$PWD/$(basename $1)

  if [ -f "$myhosts" ]; then
    ln -fs $myhosts $hosts_dir/myhosts
  fi
fi

cd $hosts_dir

# Patch /etc/hosts
pip3 install --user -r requirements.txt
python3 updateHostsFile.py -a -f -r -e fakenews gambling porn social

rm -rf $hosts_dir

redpajama_set_name: RedPajamaGithub


text:
package mygalaxy.vk;

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

import mygalaxy.domain.Node;
import mygalaxy.graphing.DataProvider;
import mygalaxy.vk.api.domain.User;
import mygalaxy.vk.api.friends.Friends;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;

@Component
public class VkDataProvider implements DataProvider {

	@Autowired
	private Friends friends;

	@Override
	public Multimap<Node, Node> getData(String userId) {
		Multimap<Node, Node> connections = HashMultimap.create();

		Node center = new Node();// TODO implement user.get
		center.setId(userId);

		List<User> firstStep = friends.get(center.getId());
		List<Node> nodes = new ArrayList<>();
		for (User user : firstStep) {
			nodes.add(new Node(user));
		}
		// connections.putAll(center, nodes);//remove self

		for (Node node : nodes) {
			populateConnections4User(connections, node, nodes);
		}

		return connections;
	}

	private List<Node> populateConnections4User(Multimap<Node, Node> connections, Node center, List<Node> all) {
		List<User> list = friends.get(center.getId());
		List<Node> nodes = new ArrayList<>();
		for (User user : list) {
			Node node = new Node(user);
			if (all.contains(node)) {// TODO add tails
				nodes.add(node);
			}
		}
		connections.putAll(center, nodes);
		return nodes;
	}

	// FIXME seems like code smells
	public void setAccessToken(String accessToken) {
		this.friends.setAccessToken(accessToken);
	}

}


text:
if(!window.hdma){window.hdma={}}

hdma.layer={
	/**
	 * create marker cluster layer
	 * @require L.MarkerClusterGroup. please download from https://github.com/Leaflet/Leaflet.markercluster
	 * @param {geojson} geojson
	 * @param {L_geojson_options} L.geojson.options. please refer to https://github.com/Leaflet/Leaflet.markercluster
	 * @param {object} events, including "clusterclick", "clustermouseover"
	 * @return {object} return object includes .markercluster and .layer(L.geojson)
	 */
	markerCluster: function(geojson, L_geojson_options, events){
		var markercluster= new L.MarkerClusterGroup({spiderfyOnMaxZoom: true, showCoverageOnHover: true, zoomToBoundsOnClick: false, animateAddingMarkers:false });

		//add L_geojson_options to markerCluster options
		$.each(L_geojson_options, function(k,v){
			markercluster.options[k]=v;
		});

		if(L_geojson_options.onEachFeature){
			var clone_onEachFeature=L_geojson_options.onEachFeature;
			L_geojson_options.onEachFeature=function(feature, layer){
				clone_onEachFeature(feature, layer);
				markercluster.addLayer(layer);
			}
		}

		var layer=L.geoJson(geojson, L_geojson_options);

		//overwrite markercluster events
		if(events){
			if(events.clusterclick){markercluster.on("clusterclick", events.clusterclick);}
			if(events.clustermouseover){markercluster.on("clustermouseover", events.clustermouseover);}
		}

		return markercluster
	},

	/**
	 * create a heatmap
	 * @require heatmap.js and heatmap-leaflet.js from https://github.com/sunng87/heatcanvas
	 * @param {geojson} geojson
	 * @param {object} heatCanvas options from https://github.com/sunng87/heatcanvas
	 * @return
	 */
	heatMap: function(geojson, radius, options){
		if(!geojson){console.log("[ERROR] hdma.layer.heatMap: no geojson!");return;}

		//zoomLevel
		if(!radius){radius=0}

		//options
		if(!options){options={}}
		//options.unloadInvisibleTiles= options.unloadInvisibleTiles || true;
		//options.reuseTiles= options.reuseTiles || true;
		//options.radius= options.radius || 30;
		//options.radius= options.radius || { value: 300, absolute: true };
		//alert("Radius before heatMap = "+radius);
		options.radius= options.radius || { value: radius, absolute: true };
		options.opacity= options.opacity || 0.8;
		options.gradient= options.gradient || {
				0.45: "rgb(0,0,255)",
				0.65: "rgb(0,255,255)",
				0.85: "rgb(0,255,0)",
				0.99: "yellow",
				1.0: "rgb(255,0,0)"
		};

		var heatmapLayer = L.TileLayer.heatMap(options);

		var hitMapData={
	    	max:  1, // Always 1 in tweet data
			data: []
	    };

		//parse geojson
		//feature collection
		if(geojson.type=='FeatureCollection'){
			var feature;
			for(var i in geojson.features){
				feature=geojson.features[i];
				if(feature.geometry.type=='Point'){
					hitMapData.data.push({lat: feature.geometry.coordinates[1], lon: feature.geometry.coordinates[0], value: 1});
				}
			}
		}
		//features
		if(geojson instanceof Array){
			var feature;
			for(var i in geojson){
				feature=geojson[i];
				if(feature.geometry.type=='Point'){
					hitMapData.data.push({lat: feature.geometry.coordinates[1], lon: feature.geometry.coordinates[0], value: 1});
				}
			}
		}

		//heatmapLayer.setData(hitMapData.data);
		return heatmapLayer;
	},

	//basemap layers
	basemaps: {
		"Light Gray Background Map" : function(){return L.tileLayer("http://{s}.tile.cloudmade.com/BC9A493B41014CAABB98F0471D759707/{styleId}/256/{z}/{x}/{y}.png", {
			styleId : 22677,
			attribution : "Map Provided by Cloudmade",
			title : "Light Gray Background Map"
		})},
		"OpenStreet Map" : function(){return L.tileLayer("http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", {
			attribution : "Map Provided by Open Street Map",
			title : "OpenStreet Map",
			maxZoom:19
		})},
		"ESRI Imagery Map" : function(){
			var layer=L.layerGroup([
				L.tileLayer("http://server.arcgisonline.com/ArcGIS/rest/services/{serviceName}/MapServer/tile/{z}/{y}/{x}", {
					serviceName: "World_Imagery",
					attribution : "Map Provided by ESRI",
					title : "ESRI Imagery Map"
				}),
				L.tileLayer("http://server.arcgisonline.com/ArcGIS/rest/services/{serviceName}/MapServer/tile/{z}/{y}/{x}", {
					serviceName: "Reference/World_Boundaries_and_Places",
					attribution : "Map Provided by ESRI",
					title : "ESRI Imagery Map"
				})
			]);
			layer.options=layer.options || {}
			layer.options.title="ESRI Imagery Map";
			return layer
		},
		"ESRI Street Map" : function(){return L.tileLayer("http://server.arcgisonline.com/ArcGIS/rest/services/{serviceName}/MapServer/tile/{z}/{y}/{x}", {
			serviceName: "World_Street_Map",
			attribution : "Map Provided by ESRI",
			title : "ESRI Street Map"
		})},
		"ESRI National Geographic Map" : function(){return L.tileLayer("http://server.arcgisonline.com/ArcGIS/rest/services/{serviceName}/MapServer/tile/{z}/{y}/{x}", {
			serviceName: "NatGeo_World_Map",
			attribution : "Map Provided by ESRI",
			title : "ESRI National Geographic Map",
			maxZoom:16
		})},
		"ESRI Terrain Map" : function(){return L.layerGroup([
			L.tileLayer("http://server.arcgisonline.com/ArcGIS/rest/services/{serviceName}/MapServer/tile/{z}/{y}/{x}", {
				serviceName: "World_Terrain_Base",
				attribution : "Map Provided by ESRI",
				title : "ESRI Terrain Map",
				maxZoom:13
			}),
			L.tileLayer("http://server.arcgisonline.com/ArcGIS/rest/services/{serviceName}/MapServer/tile/{z}/{y}/{x}", {
				serviceName: "Reference/World_Reference_Overlay",
				attribution : "Map Provided by ESRI",
				title : "ESRI Terrain Map",
				maxZoom:13
			}),
		])},
		"ESRI Topographic Map" : function(){return L.tileLayer("http://server.arcgisonline.com/ArcGIS/rest/services/{serviceName}/MapServer/tile/{z}/{y}/{x}", {
			serviceName: "World_Topo_Map",
			attribution : "Map Provided by ESRI",
			title : "ESRI Topographic Map"
		})},
		"ESRI Light Gray Map" : function(){return L.tileLayer("http://server.arcgisonline.com/ArcGIS/rest/services/{serviceName}/MapServer/tile/{z}/{y}/{x}", {
			serviceName: "Canvas/World_Light_Gray_Base",
			attribution : "Map Provided by ESRI",
			title : "ESRI Light Gray Map",
			maxZoom:16
		})},
		"ESRI Ocean Map" : function(){return L.tileLayer("http://server.arcgisonline.com/ArcGIS/rest/services/{serviceName}/MapServer/tile/{z}/{y}/{x}", {
			serviceName: "Ocean_Basemap",
			attribution : "Map Provided by ESRI",
			title : "ESRI Ocean Map",
			maxZoom:12
		})},
		"NASA NightView Map" : function(){return L.tileLayer("https://earthbuilder.googleapis.com/10446176163891957399-13737975182519107424-4/2/maptile/maps?v=2&authToken=Cgjo9hMJn-uqFhDcgMGiBQ==&x={x}&y={y}&z={z}&s=", {
			serviceName: "Night_View_Map",
			attribution : "Map Provided by  NASA Earth Observatory/NOAA NGDC",
			title : "NASA NightView Map",
			maxZoom:15
		})},
		"Google Streetmap":function(){return L.tileLayer("https://mts{s}.googleapis.com/vt?lyrs=m@207265067&src=apiv3&hl=zh-TW&x={x}&y={y}&z={z}&s=Ga&style=api%7Csmartmaps",{subdomains:"123", attribution:"Map Source from Google"})}
	},

}


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

<title>SequenceTransformer</title>
<meta name="date" content="2016-09-19">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

org.deeplearning4j.models.sequencevectors.transformers

Interface SequenceTransformer<T extends SequenceElement,V>

All Known Implementing Classes:

SentenceTransformer

public interface SequenceTransformer<T extends SequenceElement,V>

Method Summary

All Methods Instance Methods Abstract Methods

Modifier and Type
Method and Description

Sequence<T>
transformToSequence(V object)

This is generic method for transformation data from any format to Sequence of SequenceElement.

Method Detail

transformToSequence

Sequence<T> transformToSequence(V object)

This is generic method for transformation data from any format to Sequence of SequenceElement.
 It will be used both in Vocab building, and in training process

Parameters:

object - - Object to be transformed into Sequence

Returns:

Skip navigation links

Overview

Package

Class

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method


text:
title: 'Al Franken, Giant of the Senate'
written_by: Al Franken
available: 'May 30th, 2017'
isbn: '9781455540419'
binding: Hardcover
link_to_buy_page:
image_path: 'https://images.booksense.com/images/419/540/9781455540419.jpg'
link:
---


text:
<!DOCTYPE HTML>

  <meta charset="utf-8">
  <title>timezones Tests</title>
  <link rel="stylesheet" href="../node_modules/mocha/mocha.css" />


text:
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;
using System;
using System.Collections.Generic;

namespace StephJob.Migrations
{
    public partial class AddTableGreenGoodServices : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "GreenGoodServices",
                columns: table => new
                {
                    GreenGoodServiceId = table.Column<int>(type: "int", nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    GgsEmployment = table.Column<int>(type: "int", nullable: false),
                    GgsPercent = table.Column<decimal>(type: "decimal(18, 2)", nullable: false),
                    Industry = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    NaicsCode2Digit = table.Column<string>(type: "nvarchar(max)", nullable: true),
                    TotalEmployment = table.Column<int>(type: "int", nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_GreenGoodServices", x => x.GreenGoodServiceId);
                });
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "GreenGoodServices");
        }
    }
}


text:
package org.springframework.ldap.core.support;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.ldap.core.ContextSource;
import org.springframework.ldap.core.DirContextProxy;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.support.LdapUtils;

import javax.naming.directory.DirContext;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * A {@link ContextSource} to be used as a decorator around a target ContextSource
 * to make sure the target is never actually closed. Useful when working with e.g. paged results,
 * as these require the same target to be used.
 *
 * @author Mattias Hellborg Arthursson
 */
public class SingleContextSource implements ContextSource, DisposableBean {

    private static final Logger LOG = LoggerFactory.getLogger(SingleContextSource.class);
    private static final boolean DONT_USE_READ_ONLY = false;
    private static final boolean DONT_IGNORE_PARTIAL_RESULT = false;
    private static final boolean DONT_IGNORE_NAME_NOT_FOUND = false;

    private final DirContext ctx;

    /**
     * Constructor.
     *
     * @param ctx the target DirContext.
     */
    public SingleContextSource(DirContext ctx) {
        this.ctx = ctx;
    }

    /*
      * @see org.springframework.ldap.ContextSource#getReadOnlyContext()
      */
    public DirContext getReadOnlyContext() {
        return getNonClosingDirContextProxy(ctx);
    }

    /*
      * @see org.springframework.ldap.ContextSource#getReadWriteContext()
      */
    public DirContext getReadWriteContext() {
        return getNonClosingDirContextProxy(ctx);
    }

    private DirContext getNonClosingDirContextProxy(DirContext context) {
        return (DirContext) Proxy.newProxyInstance(DirContextProxy.class
                .getClassLoader(), new Class<?>[]{
                LdapUtils.getActualTargetClass(context),
                DirContextProxy.class},
                new SingleContextSource.NonClosingDirContextInvocationHandler(
                        context));

    }

    public DirContext getContext(String principal, String credentials) {
        throw new UnsupportedOperationException(
                "Not a valid operation for this type of ContextSource");
    }

    /**
     * Destroy method that allows the target DirContext to be cleaned up when
     * the SingleContextSource is not going to be used any more.
     */
    public void destroy() {
        try {
            ctx.close();
        }
        catch (javax.naming.NamingException e) {
            LOG.warn("Error when closing", e);
        }
    }

    /**
     * Construct a SingleContextSource and execute the LdapOperationsCallback using the created instance.
     * This makes sure the same connection will be used for all operations inside the LdapOperationsCallback,
     * which is particularly useful when working with e.g. Paged Results as these typically require the exact
     * same connection to be used for all requests involving the same cookie.
     * The SingleContextSource instance will be properly disposed of once the operation has been completed.
     *
By default, the {@link org.springframework.ldap.core.ContextSource#getReadWriteContext()} method
     * will be used to create the DirContext instance to operate on.

     *
     * @param contextSource The target ContextSource to retrieve a DirContext from.
     * @param callback the callback to perform the Ldap operations.
     * @return the result returned from the callback.
     * @see #doWithSingleContext(org.springframework.ldap.core.ContextSource, LdapOperationsCallback, boolean, boolean, boolean)
     * @since 2.0
     */
    public static <T> T doWithSingleContext(ContextSource contextSource, LdapOperationsCallback<T> callback) {
        return doWithSingleContext(contextSource, callback, DONT_USE_READ_ONLY, DONT_IGNORE_PARTIAL_RESULT, DONT_IGNORE_NAME_NOT_FOUND);

    }

    /**
     * Construct a SingleContextSource and execute the LdapOperationsCallback using the created instance.
     * This makes sure the same connection will be used for all operations inside the LdapOperationsCallback,
     * which is particularly useful when working with e.g. Paged Results as these typically require the exact
     * same connection to be used for all requests involving the same cookie..
     * The SingleContextSource instance will be properly disposed of once the operation has been completed.
     *
     * @param contextSource The target ContextSource to retrieve a DirContext from
     * @param callback the callback to perform the Ldap operations
     * @param useReadOnly if true, use the {@link org.springframework.ldap.core.ContextSource#getReadOnlyContext()}
     *                    method on the target ContextSource to get the actual DirContext instance, if false,
     *                    use {@link org.springframework.ldap.core.ContextSource#getReadWriteContext()}.
     * @param ignorePartialResultException Used for populating this property on the created LdapTemplate instance.
     * @param ignoreNameNotFoundException Used for populating this property on the created LdapTemplate instance.
     * @return the result returned from the callback.
     * @since 2.0
     */
    public static <T> T doWithSingleContext(ContextSource contextSource,
                                            LdapOperationsCallback<T> callback,
                                            boolean useReadOnly,
                                            boolean ignorePartialResultException,
                                            boolean ignoreNameNotFoundException) {
        SingleContextSource singleContextSource;
        if (useReadOnly) {
            singleContextSource = new SingleContextSource(contextSource.getReadOnlyContext());
        } else {
            singleContextSource = new SingleContextSource(contextSource.getReadWriteContext());
        }

        LdapTemplate ldapTemplate = new LdapTemplate(singleContextSource);
        ldapTemplate.setIgnorePartialResultException(ignorePartialResultException);
        ldapTemplate.setIgnoreNameNotFoundException(ignoreNameNotFoundException);

        try {
            return callback.doWithLdapOperations(ldapTemplate);
        } finally {
            singleContextSource.destroy();
        }
    }

    /**
     * A proxy for DirContext forwarding all operation to the target DirContext,
     * but making sure that no close operations will be performed.
     *
     * @author Mattias Hellborg Arthursson
     */
    public static class NonClosingDirContextInvocationHandler implements
            InvocationHandler {

        private DirContext target;

        public NonClosingDirContextInvocationHandler(DirContext target) {
            this.target = target;
        }

        /*
         * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object,
         * java.lang.reflect.Method, java.lang.Object[])
         */
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {

            String methodName = method.getName();
            if (methodName.equals("getTargetContext")) {
                return target;
            } else if (methodName.equals("equals")) {
                // Only consider equal when proxies are identical.
                return (proxy == args[0] ? Boolean.TRUE : Boolean.FALSE);
            } else if (methodName.equals("hashCode")) {
                // Use hashCode of Connection proxy.
                return proxy.hashCode();
            } else if (methodName.equals("close")) {
                // Never close the target context, as this class will only be
                // used for operations concerning the compensating transactions.
                return null;
            }

            try {
                return method.invoke(target, args);
            }
            catch (InvocationTargetException e) {
                throw e.getTargetException();
            }
        }
    }
}


text:
@interface Core (URLHandlerCategory)

- (NSArray*)tagsForPunakeaURL:(NSString*)tagURL;

@end


text:
import  Main from '../scenarios/main';

new Main();


text:
'-------------------------------------------------------------------------------------------'
' Inicio del codigo
'-------------------------------------------------------------------------------------------'
' Importando librerias
'-------------------------------------------------------------------------------------------'
Imports System.Data

'-------------------------------------------------------------------------------------------'
' Inicio de clase "rLInventarios_Numeros"
'-------------------------------------------------------------------------------------------'
Partial Class rLInventarios_Numeros
     Inherits vis2Formularios.frmReporte

    Dim loObjetoReporte As CrystalDecisions.CrystalReports.Engine.ReportDocument

	Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        Dim lcOrdenamiento As String = cusAplicacion.goReportes.pcOrden

	     Try

			Dim lcParametro0Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(0))
			Dim lcParametro0Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(0))
			Dim lcParametro1Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(1), goServicios.enuOpcionesRedondeo.KN_FechaInicioDelDia)
			Dim lcParametro1Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(1), goServicios.enuOpcionesRedondeo.KN_FechaFinDelDia)
			Dim lcParametro2Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(2))
			Dim lcParametro2Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(2))
            Dim lcParametro3Desde As String = goServicios.mObtenerListaFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(3))
            Dim lcParametro4Desde As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosIniciales(4))
            Dim lcParametro4Hasta As String = goServicios.mObtenerCampoFormatoSQL(cusAplicacion.goReportes.paParametrosFinales(4))

            Dim loComandoSeleccionar As New StringBuilder()

            loComandoSeleccionar.AppendLine(" SELECT		Libres_Inventarios.Documento, ")
            loComandoSeleccionar.AppendLine(" 				Libres_Inventarios.Fec_Ini, ")
            loComandoSeleccionar.AppendLine(" 				Libres_Inventarios.Fec_Fin, ")
            loComandoSeleccionar.AppendLine(" 				Libres_Inventarios.Cod_Mon, ")
            loComandoSeleccionar.AppendLine(" 				Libres_Inventarios.Tasa, ")
            loComandoSeleccionar.AppendLine(" 				Libres_Inventarios.Status, ")
            loComandoSeleccionar.AppendLine(" 				Libres_Inventarios.Comentario, ")
            loComandoSeleccionar.AppendLine(" 				Libres_Inventarios.Mon_Bru, ")
            loComandoSeleccionar.AppendLine(" 				Libres_Inventarios.Mon_Imp, ")
            loComandoSeleccionar.AppendLine(" 				Libres_Inventarios.Mon_Net, ")
            loComandoSeleccionar.AppendLine(" 				Monedas.Nom_Mon ")
            loComandoSeleccionar.AppendLine(" From			Libres_Inventarios, ")
            loComandoSeleccionar.AppendLine("				Monedas ")
            loComandoSeleccionar.AppendLine(" WHERE		Libres_Inventarios.Cod_Mon = Monedas.Cod_Mon ")
            loComandoSeleccionar.AppendLine(" 				AND Libres_Inventarios.Documento between " & lcParametro0Desde)
            loComandoSeleccionar.AppendLine(" 				AND " & lcParametro0Hasta)
            loComandoSeleccionar.AppendLine(" 				AND Libres_Inventarios.Fec_Ini between " & lcParametro1Desde)
            loComandoSeleccionar.AppendLine(" 				AND " & lcParametro1Hasta)
            loComandoSeleccionar.AppendLine(" 				AND Libres_Inventarios.Cod_Mon between " & lcParametro2Desde)
            loComandoSeleccionar.AppendLine(" 				AND " & lcParametro2Hasta)
            loComandoSeleccionar.AppendLine(" 				AND Libres_Inventarios.Status IN (" & lcParametro3Desde & ")")
            loComandoSeleccionar.AppendLine("               AND Libres_Inventarios.Cod_Rev between " & lcParametro4Desde)
            loComandoSeleccionar.AppendLine(" 		        AND " & lcParametro4Hasta)
            loComandoSeleccionar.AppendLine("ORDER BY      " & lcOrdenamiento)
            'loComandoSeleccionar.AppendLine(" ORDER BY		Libres_Inventarios.Documento ")

            Dim loServicios As New cusDatos.goDatos

            Dim laDatosReporte As DataSet = loServicios.mObtenerTodosSinEsquema(loComandoSeleccionar.ToString, "curReportes")

            loObjetoReporte	=  cusAplicacion.goReportes.mCargarReporte("rLInventarios_Numeros", laDatosReporte)

            Me.mTraducirReporte(loObjetoReporte)

			Me.mFormatearCamposReporte(loObjetoReporte)

            Me.crvrLInventarios_Numeros.ReportSource =	 loObjetoReporte

        Catch loExcepcion As Exception

            Me.WbcAdministradorMensajeModal.mMostrarMensajeModal("Error", _
                          "No se pudo Completar el Proceso: " & loExcepcion.Message, _
                           vis3Controles.wbcAdministradorMensajeModal.enumTipoMensaje.KN_Error, _
                           "auto", _
                           "auto")

        End Try

	End Sub

	Protected Sub Page_Unload(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Unload

	Try

		loObjetoReporte.Close()

	Catch loExcepcion As Exception

	End Try

	End Sub

End Class
'-------------------------------------------------------------------------------------------'
' Fin del codigo
'-------------------------------------------------------------------------------------------'
' JJD: 25/07/08: Codigo inicial
'-------------------------------------------------------------------------------------------'
' MVP:  04/08/08: Cambios para multi idioma, mensaje de error y clase padre.
'-------------------------------------------------------------------------------------------'
' GCR:  23/03/09: Estandarización de código y ajustes al diseño
'-------------------------------------------------------------------------------------------'
' CMS:  14/05/09: Filtro "Revisión:"
'-------------------------------------------------------------------------------------------'
' AAP:  02/07/09 : Metodo de Ordenamiento
'-------------------------------------------------------------------------------------------'


text:
package client

import (
	"fmt"
	"io/ioutil"
	"net/http/httputil"

	"github.com/gophergala2016/goad/cli/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws"
	"github.com/gophergala2016/goad/cli/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/client/metadata"
	"github.com/gophergala2016/goad/cli/Godeps/_workspace/src/github.com/aws/aws-sdk-go/aws/request"
)

// A Config provides configuration to a service client instance.
type Config struct {
	Config                  *aws.Config
	Handlers                request.Handlers
	Endpoint, SigningRegion string
}

// ConfigProvider provides a generic way for a service client to receive
// the ClientConfig without circular dependencies.
type ConfigProvider interface {
	ClientConfig(serviceName string, cfgs ...*aws.Config) Config
}

// A Client implements the base client request and response handling
// used by all service clients.
type Client struct {
	request.Retryer
	metadata.ClientInfo

	Config   aws.Config
	Handlers request.Handlers
}

// New will return a pointer to a new initialized service client.
func New(cfg aws.Config, info metadata.ClientInfo, handlers request.Handlers, options ...func(*Client)) *Client {
	svc := &Client{
		Config:     cfg,
		ClientInfo: info,
		Handlers:   handlers,
	}

	switch retryer, ok := cfg.Retryer.(request.Retryer); {
	case ok:
		svc.Retryer = retryer
	case cfg.Retryer != nil && cfg.Logger != nil:
		s := fmt.Sprintf("WARNING: %T does not implement request.Retryer; using DefaultRetryer instead", cfg.Retryer)
		cfg.Logger.Log(s)
		fallthrough
	default:
		maxRetries := aws.IntValue(cfg.MaxRetries)
		if cfg.MaxRetries == nil || maxRetries == aws.UseServiceDefaultRetries {
			maxRetries = 3
		}
		svc.Retryer = DefaultRetryer{NumMaxRetries: maxRetries}
	}

	svc.AddDebugHandlers()

	for _, option := range options {
		option(svc)
	}

	return svc
}

// NewRequest returns a new Request pointer for the service API
// operation and parameters.
func (c *Client) NewRequest(operation *request.Operation, params interface{}, data interface{}) *request.Request {
	return request.New(c.Config, c.ClientInfo, c.Handlers, c.Retryer, operation, params, data)
}

// AddDebugHandlers injects debug logging handlers into the service to log request
// debug information.
func (c *Client) AddDebugHandlers() {
	if !c.Config.LogLevel.AtLeast(aws.LogDebug) {
		return
	}

	c.Handlers.Send.PushFront(logRequest)
	c.Handlers.Send.PushBack(logResponse)
}

const logReqMsg = `DEBUG: Request %s/%s Details:
---[ REQUEST POST-SIGN ]-----------------------------
%s
-----------------------------------------------------`

func logRequest(r *request.Request) {
	logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
	dumpedBody, _ := httputil.DumpRequestOut(r.HTTPRequest, logBody)

	if logBody {
		// Reset the request body because dumpRequest will re-wrap the r.HTTPRequest's
		// Body as a NoOpCloser and will not be reset after read by the HTTP
		// client reader.
		r.Body.Seek(r.BodyStart, 0)
		r.HTTPRequest.Body = ioutil.NopCloser(r.Body)
	}

	r.Config.Logger.Log(fmt.Sprintf(logReqMsg, r.ClientInfo.ServiceName, r.Operation.Name, string(dumpedBody)))
}

const logRespMsg = `DEBUG: Response %s/%s Details:
---[ RESPONSE ]--------------------------------------
%s
-----------------------------------------------------`

func logResponse(r *request.Request) {
	var msg = "no response data"
	if r.HTTPResponse != nil {
		logBody := r.Config.LogLevel.Matches(aws.LogDebugWithHTTPBody)
		dumpedBody, _ := httputil.DumpResponse(r.HTTPResponse, logBody)
		msg = string(dumpedBody)
	} else if r.Error != nil {
		msg = r.Error.Error()
	}
	r.Config.Logger.Log(fmt.Sprintf(logRespMsg, r.ClientInfo.ServiceName, r.Operation.Name, msg))
}


text:
#include "tensorflow/core/kernels/data/options_dataset_op.h"

#include "tensorflow/core/data/dataset_test_base.h"
#include "tensorflow/core/kernels/data/range_dataset_op.h"

namespace tensorflow {
namespace data {
namespace {

constexpr char kOptions[] = R"proto(
  deterministic: true
  slack: true
  optimization_options { apply_default_optimizations: true autotune: true }
)proto";

class OptionsDatasetOpTest : public DatasetOpsTestBase {};

OptionsDatasetParams OptionsDatasetParams0() {
  Options options;
  protobuf::TextFormat::ParseFromString(kOptions, &options);
  return OptionsDatasetParams(RangeDatasetParams(0, 10, 3),
                              options.SerializeAsString(),
                              /*output_dtypes=*/{DT_INT64},
                              /*output_shapes=*/{PartialTensorShape({})},
                              /*node_name=*/"options_dataset_0");
}

OptionsDatasetParams OptionsDatasetParams1() {
  Options options;
  protobuf::TextFormat::ParseFromString(kOptions, &options);
  return OptionsDatasetParams(RangeDatasetParams(10, 0, -3),
                              options.SerializeAsString(),
                              /*output_dtypes=*/{DT_INT64},
                              /*output_shapes=*/{PartialTensorShape({})},
                              /*node_name=*/"options_dataset_1");
}

OptionsDatasetParams OptionsDatasetParams2() {
  Options options;
  protobuf::TextFormat::ParseFromString(kOptions, &options);
  return OptionsDatasetParams(RangeDatasetParams(0, 5, 1),
                              options.SerializeAsString(),
                              /*output_dtypes=*/{DT_INT64},
                              /*output_shapes=*/{PartialTensorShape({})},
                              /*node_name=*/"options_dataset_2");
}

std::vector<GetNextTestCase<OptionsDatasetParams>> GetNextTestCases() {
  return {{/*dataset_params=*/OptionsDatasetParams0(),
           /*expected_outputs=*/
           CreateTensors<int64>(TensorShape({}), {{0}, {3}, {6}, {9}})},
          {/*dataset_params=*/OptionsDatasetParams1(),
           /*expected_outputs=*/
           CreateTensors<int64>(TensorShape({}), {{10}, {7}, {4}, {1}})},
          {/*dataset_params=*/OptionsDatasetParams2(),
           /*expected_outputs=*/
           CreateTensors<int64>(TensorShape({}), {{0}, {1}, {2}, {3}, {4}})}};
}

ITERATOR_GET_NEXT_TEST_P(OptionsDatasetOpTest, OptionsDatasetParams,
                         GetNextTestCases())

TEST_F(OptionsDatasetOpTest, DatasetOptions) {
  auto dataset_params = OptionsDatasetParams0();
  TF_ASSERT_OK(Initialize(dataset_params));
  Options expected_options;
  protobuf::TextFormat::ParseFromString(kOptions, &expected_options);
  TF_ASSERT_OK(CheckDatasetOptions(expected_options));
}

TEST_F(OptionsDatasetOpTest, DatasetNodeName) {
  auto dataset_params = OptionsDatasetParams0();
  TF_ASSERT_OK(Initialize(dataset_params));
  TF_ASSERT_OK(CheckDatasetNodeName(dataset_params.node_name()));
}

TEST_F(OptionsDatasetOpTest, DatasetTypeString) {
  auto dataset_params = OptionsDatasetParams0();
  TF_ASSERT_OK(Initialize(dataset_params));
  TF_ASSERT_OK(CheckDatasetTypeString(
      name_utils::OpName(OptionsDatasetOp::kDatasetType)));
}

TEST_F(OptionsDatasetOpTest, DatasetoutputDTypes) {
  auto dataset_params = OptionsDatasetParams0();
  TF_ASSERT_OK(Initialize(dataset_params));
  TF_ASSERT_OK(CheckDatasetOutputDtypes({DT_INT64}));
}

TEST_F(OptionsDatasetOpTest, DatasetoutputShapes) {
  auto dataset_params = OptionsDatasetParams0();
  TF_ASSERT_OK(Initialize(dataset_params));
  TF_ASSERT_OK(CheckDatasetOutputShapes({PartialTensorShape({})}));
}

TEST_F(OptionsDatasetOpTest, DatasetCardinality) {
  auto dataset_params = OptionsDatasetParams0();
  TF_ASSERT_OK(Initialize(dataset_params));
  TF_ASSERT_OK(CheckDatasetCardinality(4));
}

TEST_F(OptionsDatasetOpTest, IteratorOutputDtypes) {
  auto dataset_params = OptionsDatasetParams0();
  TF_ASSERT_OK(Initialize(dataset_params));
  TF_ASSERT_OK(CheckIteratorOutputDtypes({DT_INT64}));
}

TEST_F(OptionsDatasetOpTest, IteratorOutputShapes) {
  auto dataset_params = OptionsDatasetParams0();
  TF_ASSERT_OK(Initialize(dataset_params));
  TF_ASSERT_OK(CheckIteratorOutputShapes({PartialTensorShape({})}));
}

TEST_F(OptionsDatasetOpTest, IteratorPrefix) {
  auto dataset_params = OptionsDatasetParams0();
  TF_ASSERT_OK(Initialize(dataset_params));
  TF_ASSERT_OK(CheckIteratorPrefix(name_utils::IteratorPrefix(
      RangeDatasetOp::kDatasetType, dataset_params.iterator_prefix())));
}

}  // namespace
}  // namespace data
}  // namespace tensorflow


text:
import asyncio
import time

def callback(n, loop):
    print('callback {} invoked at {}'.format(n, loop.time()))

async def main(loop):
    now = loop.time()
    print('clock time: {}'.format(time.time()))
    print('loop  time: {}'.format(now))

    print('registering callbacks')
    loop.call_at(now + 0.2, callback, 1, loop)
    loop.call_at(now + 0.1, callback, 2, loop)
    loop.call_soon(callback, 3, loop)

    await asyncio.sleep(1)

event_loop = asyncio.get_event_loop()
try:
    print('entering event loop')
    event_loop.run_until_complete(main(event_loop))
finally:
    print('closing event loop')
    event_loop.close()


text:
LAICPMSmodel
============

A Windows application for modeling laser ablation ICP-MS elemental mapping

## Download binaries

[LAICPMSmodel.exe](https://github.com/jure/LAICPMSmodel/blob/master/bin/Release/LAICPMSmodel.exe?raw=true)


text:
package com.iluwatar.dispatcher;

import java.util.LinkedList;
import java.util.List;

import com.iluwatar.action.Action;
import com.iluwatar.action.Content;
import com.iluwatar.action.ContentAction;
import com.iluwatar.action.MenuAction;
import com.iluwatar.action.MenuItem;
import com.iluwatar.store.Store;

/**
 *
 * Dispatcher sends Actions to registered Stores.
 *
 */
public class Dispatcher {

	private static Dispatcher instance = new Dispatcher();

	private List<Store> stores = new LinkedList<>();

	private Dispatcher() {
	}

	public static Dispatcher getInstance() {
		return instance;
	}

	public void registerStore(Store store) {
		stores.add(store);
	}

	public void menuItemSelected(MenuItem menuItem) {
		dispatchAction(new MenuAction(menuItem));
		switch (menuItem) {
		case HOME:
		case PRODUCTS:
		default:
			dispatchAction(new ContentAction(Content.PRODUCTS));
			break;
		case COMPANY:
			dispatchAction(new ContentAction(Content.COMPANY));
			break;
		}
	}

	private void dispatchAction(Action action) {
		stores.stream().forEach((store) -> store.onAction(action));
	}
}