text:
/**
 * controller di amministrazione agganciato al body
 */
//app.controller('adminCtrl',['$scope','$rootScope', 'commons', 'logFactory', 'authentication', function($scope,$rootScope, commons, logFactory, authentication) {
var adminCtrl = function ($anchorScroll,$scope,$rootScope, $location, commons, logFactory, authentication) {
	var log = logFactory('adminCtrl');
	log.debug ('Admin Controller');

	$scope.logout = function() {
		log.debug("l'utente " + $scope.commons.user + " sta per uscire...");
		authentication.logout().then(function( path ){
        	if ( path != null ) {
                $location.path( path );
            }
        });
	};

	$scope.goTo = function( path ){
		if (angular.isDefined(path)){
			path = path.replace(/^#/,'');
		}
		$location.path(path);
	};

	//http://www.w3.org/html/wg/drafts/html/master/browsers.html#the-indicated-part-of-the-document
	$scope.scrollTo = function(id) {
		$location.hash( id );
	    $anchorScroll();
	};

};
//}]);
adminCtrl.$inject = ['$anchorScroll','$scope','$rootScope', '$location', 'commons', 'logFactory', 'authentication'];
/**
 * carica le route di symfony: invocato nel resolve del routing di angular per ogni bundle
 */
adminCtrl.resolve = {

	routes: ['$rootScope', '$cookies', '$location', '$http', '$q', '$route', '$routeParams', 'commons', 'logFactory', 'authentication','notice', 'constants',function($rootScope, $cookies, $location, $http, $q, $route, $routeParams, commons, logFactory, authentication, notice, constants) {
		var log = logFactory('adminCtrl:resolve');
		log.debug('resolve '+ $location.path() );
		$rootScope.commons = commons.get();
		$rootScope.constants = constants;
		notice.clear();
		$rootScope.notice = notice.get();
		if ($route.current.context != $rootScope.context){
			//svuotiamo array precedente
			commons.clearContext();
			$rootScope.context = $route.current.context;
			//partiamo con array vuoto
			commons.clearContext();
		}

		$rootScope.commonsFn = commons.getFn();
		commons.set('currentPath',$location.path());

		$rootScope.modulePath = getModulePath( $rootScope.context );

		var loadRouteParams = $q.defer();
		loadRouteParams.resolve($route);

		var loadGlobalData = $q.defer();
	    if ($rootScope.conf.initUrl !== null){
		    if ($rootScope.server.routes==null){
		    	if ($location.path()!=path.login){
			    	log.debug('Devo caricare le routes');
				    $http({
			    		url    : $rootScope.conf.serverContext + $rootScope.conf.initUrl,
			    		method : "GET"
			    	}).success( function(data, status, headers, config) {
			        	$rootScope.server.routes = data.routes.routes;
			        	//console.log($rootScope.server.routes);
			      		$rootScope.server.baseUrl = data.routes.baseUrl;
			      		$rootScope.server.adminSite = data.routes.adminSite;
			      		commons.set('status', data.status);
			      		//alert('global');
			      		loadGlobalData.resolve(data.routes);
			    	}).error(function(data, status, headers, config) {
			    		log.error('errore eseguendo '+initUrl+ " "+status);
			    		loadGlobalData.reject(); // you could optionally pass error data here
					});
		    	} else {
					log.debug('Non carico le routes');
					loadGlobalData.resolve($rootScope.server.routes);
				}
			} else {
				log.debug('Ho già caricato le routes');
				loadGlobalData.resolve($rootScope.server.routes);
			}
	    } else {
	    	log.debug('Non ho routes lato server da caricare');
	    	loadGlobalData.resolve();
	    }

	    return $q.all([ loadRouteParams.promise, loadGlobalData.promise , authentication.isUserLogged() ]).then( function( res ){
				if (res[2]!=null){
					 if(res[2] != path.login){
		            	 var _routeParams = res.shift();
	            	 if ($rootScope.reloadNavigator){
	            		 $rootScope.$broadcast('$navigatorChangeNeeded', angular.fromJson( _routeParams.current.pathParams ) );//carica il navigatore di secondo livello
	            	 }
	            	 $rootScope.reloadNavigator = true;
	}
					  $location.path( res[2] );
				}
	    });
	}]
/*	Scommentare se si vuole introdurre un ritardo nella partenza della route di angular * /
	, delay : [ '$q','$timeout', function($q, $timeout) {
	    var delay = $q.defer();
	    $timeout(delay.resolve);
	    return delay.promise;
	}]
/**/
};


text:
package controllers.portlet;

import play.mvc.Controller;
import play.mvc.Result;
import views.html.portlet.portlets;

/**
 * @author lyz
 *
 */
public class PortletController extends Controller {

	/**
	 * 获取html页面
	 */
	public static Result portlet_html() {
		return ok(portlets.render());
	}

}

redpajama_set_name: RedPajamaGithub


text:
package EDU.purdue.cs.bloat.file;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;

import EDU.purdue.cs.bloat.reflect.ClassInfo;
import EDU.purdue.cs.bloat.reflect.ClassInfoLoader;

/**
 * ClassFileLoder provides an interface for loading classes from files. The
 * actual loading is done by the ClassFile itself.
 *

 * Classes may be specified by their full package name (<tt>java.lang.String</tt>),
 * or by the name of their class file (<tt>myclasses/Test.class</tt>). The
 * class path may contain directories or Zip or Jar files. Any classes that are
 * written back to disk ("committed") are placed in the output directory.
 *
 * @author Nate Nystrom (nystrom@cs.purdue.edu)
 */
public class ClassFileLoader implements ClassInfoLoader {
	public static boolean DEBUG = false;

	public static boolean USE_SYSTEM_CLASSES = true;

	private File outputDir; // Directory in which to write committed class files

	private String classpath; // Path to search for classes

	private Map openZipFiles; // zip files to search for class files

	private LinkedList cache; // We keep a cache of CACHE_LIMIT class files

	private boolean verbose;

	private static final int CACHE_LIMIT = 10;

	/**
	 * Constructor. The classpath initially consists of the contents of the
	 * <tt>java.class.path</tt> and <tt>sun.boot.class.path</tt> system
	 * properties.
	 */
	public ClassFileLoader() {
		outputDir = new File(".");
		classpath = System.getProperty("java.class.path");
		classpath += File.pathSeparator
				+ System.getProperty("sun.boot.class.path");
		if (ClassFileLoader.USE_SYSTEM_CLASSES) {
			classpath += File.pathSeparator
					+ System.getProperty("java.sys.class.path");
		}
		openZipFiles = new HashMap();
		cache = new LinkedList();
		verbose = false;
	}

	public void setVerbose(final boolean verbose) {
		this.verbose = verbose;
	}

	/**
	 * Sets the classpath.
	 */
	public void setClassPath(final String classpath) {
		this.classpath = classpath;
	}

	/**
	 * Adds to the classpath (CLASSPATH = CLASSPATH + morePath).
	 */
	public void appendClassPath(final String morePath) {
		this.classpath += File.pathSeparator + morePath;
	}

	/**
	 * Adds to the classpath (CLASSPATH = morePath + CLASSPATH).
	 */
	public void prependClassPath(final String morePath) {
		this.classpath = morePath + File.pathSeparator + this.classpath;
	}

	/**
	 * Returns the path used to search for class files.
	 */
	public String getClassPath() {
		return (this.classpath);
	}

	/**
	 * Load the class from a stream.
	 *
	 * @param inputFile
	 *            The file from which to load the class.
	 * @param stream
	 *            The stream from which to load the class.
	 * @return A ClassInfo for the class.
	 * @exception ClassNotFoundException
	 *                The class cannot be found in the class path.
	 */
	private ClassInfo loadClassFromStream(final File inputFile,
			final InputStream stream) throws ClassNotFoundException {

		final DataInputStream in = new DataInputStream(stream);
		final ClassFile file = new ClassFile(inputFile, this, in);

		return file;
	}

	/**
	 * Load the class from the file.
	 *
	 * @param file
	 *            The File from which to load a class.
	 * @return A ClassInfo for the class.
	 * @exception ClassNotFoundException
	 *                The class cannot be found in the class path.
	 */
	private ClassInfo loadClassFromFile(final File file)
			throws ClassNotFoundException {
		try {
			final InputStream in = new FileInputStream(file);

			final ClassInfo info = loadClassFromStream(file, in);

			if (verbose) {
				System.out.println("[Loaded " + info.name() + " from "
						+ file.getPath() + "]");
			}

			try {
				in.close();
			} catch (final IOException ex) {
			}

			return info;
		} catch (final FileNotFoundException e) {
			throw new ClassNotFoundException(file.getPath());
		}
	}

	/**
	 * Loads all of the classes that are contained in a zip (or jar) file.
	 * Returns an array of the <tt>ClassInfo</tt>s for the classes in the zip
	 * file.
	 */
	public ClassInfo[] loadClassesFromZipFile(final ZipFile zipFile)
			throws ClassNotFoundException {
		final ClassInfo[] infos = new ClassInfo[zipFile.size()];

		// Examine each entry in the zip file
		final Enumeration entries = zipFile.entries();
		for (int i = 0; entries.hasMoreElements(); i++) {
			final ZipEntry entry = (ZipEntry) entries.nextElement();
			if (entry.isDirectory() || !entry.getName().endsWith(".class")) {
				continue;
			}

			try {
				final InputStream stream = zipFile.getInputStream(entry);
				final File file = new File(entry.getName());

				infos[i] = loadClassFromStream(file, stream);

			} catch (final IOException ex) {
				System.err.println("IOException: " + ex);
			}
		}

		return (infos);
	}

	public ClassInfo newClass(final int modifiers, final int classIndex,
			final int superClassIndex, final int[] interfaceIndexes,
			final List constants) {
		return new ClassFile(modifiers, classIndex, superClassIndex,
				interfaceIndexes, constants, this);
	}

	/**
	 * Loads the class with the given name. Searches the class path, including
	 * zip files, for the class and then returns a data stream for the class
	 * file.
	 *
	 * @param name
	 *            The name of the class to load, including the package name.
	 * @return A ClassInfo for the class.
	 * @exception ClassNotFoundException
	 *                The class cannot be found in the class path.
	 */
	public ClassInfo loadClass(String name) throws ClassNotFoundException {
		ClassInfo file = null;

		// Check to see if name ends with ".class". If so, load the class from
		// that file. Note that this is okay because we can never have a class
		// named "class" (i.e. a class named "class" with a lower-case 'c' can
		// never be specified in a fully-specified java class name) because
		// "class" is a reserved word.

		if (name.endsWith(".class")) {
			final File nameFile = new File(name);

			if (!nameFile.exists()) {
				throw new ClassNotFoundException(name);

			} else {
				return (loadClassFromFile(nameFile));
			}
		}

		// Otherwise, we have a (possibly fully-specified) class name.
		name = name.replace('.', '/');

		// Check the cache for the class file.
		if (ClassFileLoader.DEBUG) {
			System.out
					.println("  Looking for " + name + " in cache = " + cache);
		}

		final Iterator iter = cache.iterator();

		while (iter.hasNext()) {
			file = (ClassFile) iter.next();

			if (name.equals(file.name())) {
				if (ClassFileLoader.DEBUG) {
					System.out.println("  Found " + file.name() + " in cache");
				}

				// Move to the front of the cache.
				iter.remove();
				cache.addFirst(file);

				return file;
			}
		}

		file = null;

		final String classFile = name.replace('/', File.separatorChar)
				+ ".class";

		// For each entry in the class path, search zip files and directories
		// for classFile. When found, open an InputStream and break
		// out of the loop to read the class file.
		final String path = classpath + File.pathSeparator;

		if (ClassFileLoader.DEBUG) {
			System.out.println("CLASSPATH = " + path);
		}

		int index = 0;
		int end = path.indexOf(File.pathSeparator, index);

		SEARCH: while (end >= 0) {
			final String dir = path.substring(index, end);

			File f = new File(dir);

			if (f.isDirectory()) {
				// The directory is really a directory. If the class file
				// exists, open a stream and return.
				f = new File(dir, classFile);

				if (f.exists()) {
					try {
						final InputStream in = new FileInputStream(f);

						if (verbose) {
							System.out.println("  [Loaded " + name + " from "
									+ f.getPath() + "]");
						}

						file = loadClassFromStream(f, in);

						try {
							in.close();

						} catch (final IOException ex) {
						}

						break SEARCH;

					} catch (final FileNotFoundException ex) {
					}
				}

			} else if (dir.endsWith(".zip") || dir.endsWith(".jar")) {
				// Maybe a zip file?
				try {
					ZipFile zip = (ZipFile) openZipFiles.get(dir);

					if (zip == null) {
						zip = new ZipFile(f);
						openZipFiles.put(dir, zip);
					}

					final String zipEntry = classFile.replace(
							File.separatorChar, '/');

					final ZipEntry entry = zip.getEntry(zipEntry);

					if (entry != null) {
						// Found the class file in the zip file.
						// Open a stream and return.
						if (verbose) {
							System.out.println("  [Loaded " + name + " from "
									+ f.getPath() + "]");
						}

						final InputStream in = zip.getInputStream(entry);
						file = loadClassFromStream(f, in);

						try {
							in.close();

						} catch (final IOException ex) {
						}
						break SEARCH;
					}
				} catch (final ZipException ex) {
				} catch (final IOException ex) {
				}
			}

			index = end + 1;
			end = path.indexOf(File.pathSeparator, index);
		}

		if (file == null) {
			// The class file wasn't in the class path. Try the currnet
			// directory. If not there, give up.
			final File f = new File(classFile);

			if (!f.exists()) {
				throw new ClassNotFoundException(name);
			}

			if (verbose) {
				System.out.println("  [Loaded " + name + " from " + f.getPath()
						+ "]");
			}

			try {
				final InputStream in = new FileInputStream(f);
				file = loadClassFromStream(f, in);

				try {
					in.close();
				} catch (final IOException ex) {
				}
			} catch (final FileNotFoundException ex) {
				throw new ClassNotFoundException(name);
			}
		}

		if (file == null) {
			throw new ClassNotFoundException(name);
		}

		// If we've reached the cache size limit, remove the oldest file
		// in the cache. Then add the new file.
		if (cache.size() == ClassFileLoader.CACHE_LIMIT) {
			cache.removeLast();
		}

		cache.addFirst(file);

		return file;
	}

	/**
	 * Set the directory into which commited class files should be written.
	 *
	 * @param dir
	 *            The directory.
	 */
	public void setOutputDir(final File dir) {
		outputDir = dir;
	}

	/**
	 * Get the directory into which commited class files should be written.
	 */
	public File outputDir() {
		return outputDir;
	}

	/**
	 * Writes a bunch of bytes to an output entry with the given
	 * name.
	 */
	public void writeEntry(final byte[] bytes, final String name)
			throws IOException {
		final OutputStream os = outputStreamFor(name);
		os.write(bytes);
		os.flush();
		os.close();
	}

	/**
	 * Returns an <tt>OutputStream</tt> to which a class file should be
	 * written.
	 */
	public OutputStream outputStreamFor(final ClassInfo info)
			throws IOException {
		// Format the name of the output file
		final String name = info.name().replace('/', File.separatorChar)
				+ ".class";
		return outputStreamFor(name);
	}

	/**
	 * Returns an OutputStream to which somed named entity is
	 * written. Any forward slashes in the name are replaced by
	 * File.separatorChar.
	 */
	protected OutputStream outputStreamFor(String name) throws IOException {

		name = name.replace('/', File.separatorChar);

		final File f = new File(outputDir, name);

		if (f.exists()) {
			f.delete();
		}

		final File dir = new File(f.getParent());
		dir.mkdirs();

		if (!dir.exists()) {
			throw new RuntimeException("Couldn't create directory: " + dir);
		}

		return (new FileOutputStream(f));
	}

	/**
	 * Signifies that we are done with this ClassFileLoader
	 */
	public void done() throws IOException {
		// Nothing for this guy
	}
}


text:
export default {
  BLANKET_CLICK: 'blanket.click',
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
            http://www.springframework.org/schema/util http://ww.springframework.org/schema/util/spring-util-3.0.xsd">

<!-- 所有身份认证的Bean配置 -->

	 <bean id="sysUserDAO" class="com.jon.web.dao.imp.SysUserDAOImp">
	 	<property name="sessionFactory" ref="sessionFactory"></property>
	 </bean>
	 <bean id="sysPermissionDAO" class="com.jon.web.dao.imp.SysPermissionDAOImp">
	 	<property name="sessionFactory" ref="sessionFactory"></property>
	 </bean>

<!-- 	 Warring begin-->
	<!-- 		使sysServiceManager 去继承  transactionBese  从而得到事物处理的能力 ,此方式可以避免一些问题(例如事物无法关闭,提交等)-->
	 <bean id="sysServiceBase" class="com.jon.web.service.imp.SysServiceImpl">
	 	<property name="sysUserDAO" ref="sysUserDAO"></property>
	 	<property name="sysPermissionDAO" ref="sysPermissionDAO"></property>
	 </bean>

	 <bean id="sysServiceManager" parent="transactionBese">
	 	<property name="target" ref="sysServiceBase"></property>
	 </bean>
<!-- 	 Warring end -->

</beans>


text:
import React from 'react';

const OrderLine = () => (
  <div>
    OrderLine
  </div>
);

export default OrderLine;


text:
/*
 * Do not modify this file. This file is generated from the elasticmapreduce-2009-03-31.normal.json service model.
 */
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Net;
using System.Text;
using System.Xml.Serialization;

using Amazon.ElasticMapReduce.Model;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Transform;
using Amazon.Runtime.Internal.Util;
using ThirdParty.Json.LitJson;

namespace Amazon.ElasticMapReduce.Model.Internal.MarshallTransformations
{
    /// <summary>
    /// Response Unmarshaller for HadoopJarStepConfig Object
    /// </summary>
    public class HadoopJarStepConfigUnmarshaller : IUnmarshaller<HadoopJarStepConfig, XmlUnmarshallerContext>, IUnmarshaller<HadoopJarStepConfig, JsonUnmarshallerContext>
    {
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        HadoopJarStepConfig IUnmarshaller<HadoopJarStepConfig, XmlUnmarshallerContext>.Unmarshall(XmlUnmarshallerContext context)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public HadoopJarStepConfig Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
                return null;

            HadoopJarStepConfig unmarshalledObject = new HadoopJarStepConfig();

            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("Args", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<string, StringUnmarshaller>(StringUnmarshaller.Instance);
                    unmarshalledObject.Args = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("Jar", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    unmarshalledObject.Jar = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("MainClass", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    unmarshalledObject.MainClass = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("Properties", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<KeyValue, KeyValueUnmarshaller>(KeyValueUnmarshaller.Instance);
                    unmarshalledObject.Properties = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return unmarshalledObject;
        }

        private static HadoopJarStepConfigUnmarshaller _instance = new HadoopJarStepConfigUnmarshaller();

        /// <summary>
        /// Gets the singleton.
        /// </summary>
        public static HadoopJarStepConfigUnmarshaller Instance
        {
            get
            {
                return _instance;
            }
        }
    }
}


text:
namespace Likja.ImgurNet.Models
{
    public class Account
    {
        public long Id { get; set; }
        public string Url { get; set; }
        public string Bio { get; set; }
        public float Reputation { get; set; }
        public long Created { get; set; }
        public bool ProExpiration { get; set; }
    }
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
in Inácio, Rodrigues, Sobral & Fonseca, FEMS Yeast Res. 4(4-5): 552 (2004)

#### Original name
Lalaria inositophila Á. Fonseca, J. Inácio & M.G. Rodrigues

### Remarks
null


text:
package com.badlogic.gdx.scenes.scene2d;

import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.math.Affine2;
import com.badlogic.gdx.math.Matrix4;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.scenes.scene2d.utils.Cullable;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.SnapshotArray;

/** 2D scene graph node that may contain other actors.
 * <p>
 * Actors have a z-order equal to the order they were inserted into the group. Actors inserted later will be drawn on top of
 * actors added earlier. Touch events that hit more than one actor are distributed to topmost actors first.
 * @author mzechner
 * @author Nathan Sweet */
public class Group extends Actor implements Cullable {
	static private final Vector2 tmp = new Vector2();

	final SnapshotArray<Actor> children = new SnapshotArray(true, 4, Actor.class);
	private final Affine2 worldTransform = new Affine2();
	private final Matrix4 computedTransform = new Matrix4();
	private final Matrix4 oldTransform = new Matrix4();
	boolean transform = true;
	private Rectangle cullingArea;

	public void act (float delta) {
		super.act(delta);
		Actor[] actors = children.begin();
		for (int i = 0, n = children.size; i < n; i++)
			actors[i].act(delta);
		children.end();
	}

	/** Draws the group and its children. The default implementation calls {@link #applyTransform(Batch, Matrix4)} if needed, then
	 * {@link #drawChildren(Batch, float)}, then {@link #resetTransform(Batch)} if needed. */
	public void draw (Batch batch, float parentAlpha) {
		if (transform) applyTransform(batch, computeTransform());
		drawChildren(batch, parentAlpha);
		if (transform) resetTransform(batch);
	}

	/** Draws all children. {@link #applyTransform(Batch, Matrix4)} should be called before and {@link #resetTransform(Batch)}
	 * after this method if {@link #setTransform(boolean) transform} is true. If {@link #setTransform(boolean) transform} is false
	 * these methods don't need to be called, children positions are temporarily offset by the group position when drawn. This
	 * method avoids drawing children completely outside the {@link #setCullingArea(Rectangle) culling area}, if set. */
	protected void drawChildren (Batch batch, float parentAlpha) {
		parentAlpha *= this.color.a;
		SnapshotArray<Actor> children = this.children;
		Actor[] actors = children.begin();
		Rectangle cullingArea = this.cullingArea;
		if (cullingArea != null) {
			// Draw children only if inside culling area.
			float cullLeft = cullingArea.x;
			float cullRight = cullLeft + cullingArea.width;
			float cullBottom = cullingArea.y;
			float cullTop = cullBottom + cullingArea.height;
			if (transform) {
				for (int i = 0, n = children.size; i < n; i++) {
					Actor child = actors[i];
					if (!child.isVisible()) continue;
					float cx = child.x, cy = child.y;
					if (cx <= cullRight && cy <= cullTop && cx + child.width >= cullLeft && cy + child.height >= cullBottom)
						child.draw(batch, parentAlpha);
				}
			} else {
				// No transform for this group, offset each child.
				float offsetX = x, offsetY = y;
				x = 0;
				y = 0;
				for (int i = 0, n = children.size; i < n; i++) {
					Actor child = actors[i];
					if (!child.isVisible()) continue;
					float cx = child.x, cy = child.y;
					if (cx <= cullRight && cy <= cullTop && cx + child.width >= cullLeft && cy + child.height >= cullBottom) {
						child.x = cx + offsetX;
						child.y = cy + offsetY;
						child.draw(batch, parentAlpha);
						child.x = cx;
						child.y = cy;
					}
				}
				x = offsetX;
				y = offsetY;
			}
		} else {
			// No culling, draw all children.
			if (transform) {
				for (int i = 0, n = children.size; i < n; i++) {
					Actor child = actors[i];
					if (!child.isVisible()) continue;
					child.draw(batch, parentAlpha);
				}
			} else {
				// No transform for this group, offset each child.
				float offsetX = x, offsetY = y;
				x = 0;
				y = 0;
				for (int i = 0, n = children.size; i < n; i++) {
					Actor child = actors[i];
					if (!child.isVisible()) continue;
					float cx = child.x, cy = child.y;
					child.x = cx + offsetX;
					child.y = cy + offsetY;
					child.draw(batch, parentAlpha);
					child.x = cx;
					child.y = cy;
				}
				x = offsetX;
				y = offsetY;
			}
		}
		children.end();
	}

	/** Draws this actor's debug lines if {@link #getDebug()} is true and, regardless of {@link #getDebug()}, calls
	 * {@link Actor#drawDebug(ShapeRenderer)} on each child. */
	public void drawDebug (ShapeRenderer shapes) {
		drawDebugBounds(shapes);
		if (transform) applyTransform(shapes, computeTransform());
		drawDebugChildren(shapes);
		if (transform) resetTransform(shapes);
	}

	/** Draws all children. {@link #applyTransform(Batch, Matrix4)} should be called before and {@link #resetTransform(Batch)}
	 * after this method if {@link #setTransform(boolean) transform} is true. If {@link #setTransform(boolean) transform} is false
	 * these methods don't need to be called, children positions are temporarily offset by the group position when drawn. This
	 * method avoids drawing children completely outside the {@link #setCullingArea(Rectangle) culling area}, if set. */
	protected void drawDebugChildren (ShapeRenderer shapes) {
		SnapshotArray<Actor> children = this.children;
		Actor[] actors = children.begin();
		// No culling, draw all children.
		if (transform) {
			for (int i = 0, n = children.size; i < n; i++) {
				Actor child = actors[i];
				if (!child.isVisible()) continue;
				if (!child.getDebug() && !(child instanceof Group)) continue;
				child.drawDebug(shapes);
			}
			shapes.flush();
		} else {
			// No transform for this group, offset each child.
			float offsetX = x, offsetY = y;
			x = 0;
			y = 0;
			for (int i = 0, n = children.size; i < n; i++) {
				Actor child = actors[i];
				if (!child.isVisible()) continue;
				if (!child.getDebug() && !(child instanceof Group)) continue;
				float cx = child.x, cy = child.y;
				child.x = cx + offsetX;
				child.y = cy + offsetY;
				child.drawDebug(shapes);
				child.x = cx;
				child.y = cy;
			}
			x = offsetX;
			y = offsetY;
		}
		children.end();
	}

	/** Returns the transform for this group's coordinate system. */
	protected Matrix4 computeTransform () {
		Affine2 worldTransform = this.worldTransform;
		float originX = this.originX, originY = this.originY;
		worldTransform.setToTrnRotScl(x + originX, y + originY, rotation, scaleX, scaleY);
		if (originX != 0 || originY != 0) worldTransform.translate(-originX, -originY);

		// Find the first parent that transforms.
		Group parentGroup = parent;
		while (parentGroup != null) {
			if (parentGroup.transform) break;
			parentGroup = parentGroup.parent;
		}
		if (parentGroup != null) worldTransform.preMul(parentGroup.worldTransform);

		computedTransform.set(worldTransform);
		return computedTransform;
	}

	/** Set the batch's transformation matrix, often with the result of {@link #computeTransform()}. Note this causes the batch to
	 * be flushed. {@link #resetTransform(Batch)} will restore the transform to what it was before this call. */
	protected void applyTransform (Batch batch, Matrix4 transform) {
		oldTransform.set(batch.getTransformMatrix());
		batch.setTransformMatrix(transform);
	}

	/** Restores the batch transform to what it was before {@link #applyTransform(Batch, Matrix4)}. Note this causes the batch to
	 * be flushed. */
	protected void resetTransform (Batch batch) {
		batch.setTransformMatrix(oldTransform);
	}

	/** Set the shape renderer transformation matrix, often with the result of {@link #computeTransform()}. Note this causes the
	 * shape renderer to be flushed. {@link #resetTransform(ShapeRenderer)} will restore the transform to what it was before this
	 * call. */
	protected void applyTransform (ShapeRenderer shapes, Matrix4 transform) {
		oldTransform.set(shapes.getTransformMatrix());
		shapes.setTransformMatrix(transform);
	}

	/** Restores the shape renderer transform to what it was before {@link #applyTransform(Batch, Matrix4)}. Note this causes the
	 * shape renderer to be flushed. */
	protected void resetTransform (ShapeRenderer shapes) {
		shapes.setTransformMatrix(oldTransform);
	}

	/** Children completely outside of this rectangle will not be drawn. This is only valid for use with unrotated and unscaled
	 * actors.
	 * @param cullingArea May be null. */
	public void setCullingArea (Rectangle cullingArea) {
		this.cullingArea = cullingArea;
	}

	/** @return May be null.
	 * @see #setCullingArea(Rectangle) */
	public Rectangle getCullingArea () {
		return cullingArea;
	}

	public Actor hit (float x, float y, boolean touchable) {
		if (touchable && getTouchable() == Touchable.disabled) return null;
		Vector2 point = tmp;
		Actor[] childrenArray = children.items;
		for (int i = children.size - 1; i >= 0; i--) {
			Actor child = childrenArray[i];
			if (!child.isVisible()) continue;
			child.parentToLocalCoordinates(point.set(x, y));
			Actor hit = child.hit(point.x, point.y, touchable);
			if (hit != null) return hit;
		}
		return super.hit(x, y, touchable);
	}

	/** Called when actors are added to or removed from the group. */
	protected void childrenChanged () {
	}

	/** Adds an actor as a child of this group, removing it from its previous parent. If the actor is already a child of this
	 * group, no changes are made. */
	public void addActor (Actor actor) {
		if (actor.parent != null) {
			if (actor.parent == this) return;
			actor.parent.removeActor(actor, false);
		}
		children.add(actor);
		actor.setParent(this);
		actor.setStage(getStage());
		childrenChanged();
	}

	/** Adds an actor as a child of this group at a specific index, removing it from its previous parent. If the actor is already a
	 * child of this group, no changes are made.
	 * @param index May be greater than the number of children. */
	public void addActorAt (int index, Actor actor) {
		if (actor.parent != null) {
			if (actor.parent == this) return;
			actor.parent.removeActor(actor, false);
		}
		if (index >= children.size)
			children.add(actor);
		else
			children.insert(index, actor);
		actor.setParent(this);
		actor.setStage(getStage());
		childrenChanged();
	}

	/** Adds an actor as a child of this group immediately before another child actor, removing it from its previous parent. If the
	 * actor is already a child of this group, no changes are made. */
	public void addActorBefore (Actor actorBefore, Actor actor) {
		if (actor.parent != null) {
			if (actor.parent == this) return;
			actor.parent.removeActor(actor, false);
		}
		int index = children.indexOf(actorBefore, true);
		children.insert(index, actor);
		actor.setParent(this);
		actor.setStage(getStage());
		childrenChanged();
	}

	/** Adds an actor as a child of this group immediately after another child actor, removing it from its previous parent. If the
	 * actor is already a child of this group, no changes are made. */
	public void addActorAfter (Actor actorAfter, Actor actor) {
		if (actor.parent != null) {
			if (actor.parent == this) return;
			actor.parent.removeActor(actor, false);
		}
		int index = children.indexOf(actorAfter, true);
		if (index == children.size)
			children.add(actor);
		else
			children.insert(index + 1, actor);
		actor.setParent(this);
		actor.setStage(getStage());
		childrenChanged();
	}

	/** Removes an actor from this group and unfocuses it. Calls {@link #removeActor(Actor, boolean)} with true. */
	public boolean removeActor (Actor actor) {
		return removeActor(actor, true);
	}

	/** Removes an actor from this group. If the actor will not be used again and has actions, they should be
	 * {@link Actor#clearActions() cleared} so the actions will be returned to their
	 * {@link Action#setPool(com.badlogic.gdx.utils.Pool) pool}, if any. This is not done automatically.
	 * @param unfocus If true, {@link Stage#unfocus(Actor)} is called.
	 * @return true if the actor was removed from this group. */
	public boolean removeActor (Actor actor, boolean unfocus) {
		if (!children.removeValue(actor, true)) return false;
		if (unfocus) {
			Stage stage = getStage();
			if (stage != null) stage.unfocus(actor);
		}
		actor.setParent(null);
		actor.setStage(null);
		childrenChanged();
		return true;
	}

	/** Removes all actors from this group. */
	public void clearChildren () {
		Actor[] actors = children.begin();
		for (int i = 0, n = children.size; i < n; i++) {
			Actor child = actors[i];
			child.setStage(null);
			child.setParent(null);
		}
		children.end();
		children.clear();
		childrenChanged();
	}

	/** Removes all children, actions, and listeners from this group. */
	public void clear () {
		super.clear();
		clearChildren();
	}

	/** Returns the first actor found with the specified name. Note this recursively compares the name of every actor in the
	 * group. */
	public <T extends Actor> T findActor (String name) {
		Array<Actor> children = this.children;
		for (int i = 0, n = children.size; i < n; i++)
			if (name.equals(children.get(i).getName())) return (T)children.get(i);
		for (int i = 0, n = children.size; i < n; i++) {
			Actor child = children.get(i);
			if (child instanceof Group) {
				Actor actor = ((Group)child).findActor(name);
				if (actor != null) return (T)actor;
			}
		}
		return null;
	}

	protected void setStage (Stage stage) {
		super.setStage(stage);
		Actor[] childrenArray = children.items;
		for (int i = 0, n = children.size; i < n; i++)
			childrenArray[i].setStage(stage); // StackOverflowError here means the group is its own ancestor.
	}

	/** Swaps two actors by index. Returns false if the swap did not occur because the indexes were out of bounds. */
	public boolean swapActor (int first, int second) {
		int maxIndex = children.size;
		if (first < 0 || first >= maxIndex) return false;
		if (second < 0 || second >= maxIndex) return false;
		children.swap(first, second);
		return true;
	}

	/** Swaps two actors. Returns false if the swap did not occur because the actors are not children of this group. */
	public boolean swapActor (Actor first, Actor second) {
		int firstIndex = children.indexOf(first, true);
		int secondIndex = children.indexOf(second, true);
		if (firstIndex == -1 || secondIndex == -1) return false;
		children.swap(firstIndex, secondIndex);
		return true;
	}

	/** Returns an ordered list of child actors in this group. */
	public SnapshotArray<Actor> getChildren () {
		return children;
	}

	public boolean hasChildren () {
		return children.size > 0;
	}

	/** When true (the default), the Batch is transformed so children are drawn in their parent's coordinate system. This has a
	 * performance impact because {@link Batch#flush()} must be done before and after the transform. If the actors in a group are
	 * not rotated or scaled, then the transform for the group can be set to false. In this case, each child's position will be
	 * offset by the group's position for drawing, causing the children to appear in the correct location even though the Batch has
	 * not been transformed. */
	public void setTransform (boolean transform) {
		this.transform = transform;
	}

	public boolean isTransform () {
		return transform;
	}

	/** Converts coordinates for this group to those of a descendant actor. The descendant does not need to be a direct child.
	 * @throws IllegalArgumentException if the specified actor is not a descendant of this group. */
	public Vector2 localToDescendantCoordinates (Actor descendant, Vector2 localCoords) {
		Group parent = descendant.parent;
		if (parent == null) throw new IllegalArgumentException("Child is not a descendant: " + descendant);
		// First convert to the actor's parent coordinates.
		if (parent != this) localToDescendantCoordinates(parent, localCoords);
		// Then from each parent down to the descendant.
		descendant.parentToLocalCoordinates(localCoords);
		return localCoords;
	}

	/** If true, {@link #drawDebug(ShapeRenderer)} will be called for this group and, optionally, all children recursively. */
	public void setDebug (boolean enabled, boolean recursively) {
		setDebug(enabled);
		if (recursively) {
			for (Actor child : children) {
				if (child instanceof Group) {
					((Group)child).setDebug(enabled, recursively);
				} else {
					child.setDebug(enabled);
				}
			}
		}
	}

	/** Calls {@link #setDebug(boolean, boolean)} with {@code true, true}. */
	public Group debugAll () {
		setDebug(true, true);
		return this;
	}

	/** Returns a description of the actor hierarchy, recursively. */
	public String toString () {
		StringBuilder buffer = new StringBuilder(128);
		toString(buffer, 1);
		buffer.setLength(buffer.length() - 1);
		return buffer.toString();
	}

	void toString (StringBuilder buffer, int indent) {
		buffer.append(super.toString());
		buffer.append('\n');

		Actor[] actors = children.begin();
		for (int i = 0, n = children.size; i < n; i++) {
			for (int ii = 0; ii < indent; ii++)
				buffer.append("|  ");
			Actor actor = actors[i];
			if (actor instanceof Group)
				((Group)actor).toString(buffer, indent + 1);
			else {
				buffer.append(actor);
				buffer.append('\n');
			}
		}
		children.end();
	}
}


text:
package com.hexpang.model;

import com.hexpang.odoo.APIHelper;
import com.hexpang.orm.Entity;
import org.apache.xmlrpc.XmlRpcException;

import java.net.MalformedURLException;
import java.util.Arrays;
import java.util.List;

/**
 * Created by HexPang on 2017/3/30.
 */
public class BaseModel extends Entity {
    private static APIHelper apiHelper = null;
    public static String AuthToken = null;
    public static APIHelper getApiHelper(){
        if(apiHelper == null){
            apiHelper = new APIHelper();
            String[] accs = AuthToken.split(":");
            int uid = apiHelper.Authenticate(accs[0], accs[1]);
        }
        return apiHelper;
    }

    public <T> T[] All(){
        try {
            return getApiHelper().searchRead(Table(),this.getClass(),Arrays.asList("id",">",0));
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (XmlRpcException e) {
            e.printStackTrace();
        }
        return null;
    }

    public int Create(){
        try {
            return getApiHelper().create(Table(),this.toMap());
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (XmlRpcException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        return 0;
    }

    public boolean Update(){
        String pk = PrimaryKey();
        int id = Integer.valueOf(this.ModelId());
        if(id > 0){
            try {
                return getApiHelper().write(Table(),id,this.toMap());
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (XmlRpcException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    public <T> T Find(int id){
        String pk = this.PrimaryKey();
        return this.Find(Arrays.asList(pk,"=",id));
    }

    public <T> T Find(String id){
        String pk = this.PrimaryKey();
        return this.Find(Arrays.asList(pk,"=",id));
    }

    @Override
    public String toString() {
        try {
            return this.toMap().toString();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return super.toString();
    }

    public <T> T Find(List list){
        try {
            return (T) getApiHelper().searchRead(Table(),this.getClass(),list);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (XmlRpcException e) {
            e.printStackTrace();
        }
        return null;
    }
}


text:
package main

import (
	"fmt"
	"log"
	"net/http"

	"github.com/seedboxtech/gobstopper"
	"github.com/seedboxtech/gobstopper/examples/middleware"
)

func main() {
	conf := gobstopper.Config{
		Port: 8000,
		// Negroni: negroni.New(),
		PathPrefix: "/v1",
	}

	server, err := gobstopper.NewServer(conf)
	if err != nil {
		log.Fatal("Unable to start server!")
	}

	server.Route(gobstopper.Route{
		Method: "GET",
		Path:   "/foo",
		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			fmt.Fprintln(w, "hello")
		}),
	})

	server.RouteGroup("/admin", func(group *gobstopper.Group) {
		group.Middleware(middleware.TerribleAuthMiddleware{})
		group.Route(gobstopper.Route{
			Method: "GET",
			Path:   "",
			Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				fmt.Fprintln(w, "admin")
			}),
		})
	})

	server.Start()

}


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

<title>MediationInterstitialListener (Google AdMob Ads SDK)</title>
<meta name="date" content="2013-04-15">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

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

com.google.ads.mediation

Interface MediationInterstitialListener

public interface MediationInterstitialListener

Callback for an adapter to communicate back to the mediation library.  Events must
 be communicated back for the mediation library to properly manage ad flow.

Method Summary

Methods

Modifier and Type
Method and Description

void
onDismissScreen(MediationInterstitialAdapter<?,?> adapter)

Indicates that the ad control rendered something in full screen and is now transferring
 control back to the application.

void
onFailedToReceiveAd(MediationInterstitialAdapter<?,?> adapter,
                   AdRequest.ErrorCode error)

Indicates that an ad request has failed along with the underlying cause.

void
onLeaveApplication(MediationInterstitialAdapter<?,?> adapter)

Indicates that the ad is causing the device to switch to a different application (such as a
 web browser).

void
onPresentScreen(MediationInterstitialAdapter<?,?> adapter)

Indicates that the ad control is rendering something that is full screen.

void
onReceivedAd(MediationInterstitialAdapter<?,?> adapter)

Indicates that an ad has been requested and successfully received.

Method Detail

onReceivedAd

void onReceivedAd(MediationInterstitialAdapter<?,?> adapter)

Indicates that an ad has been requested and successfully received.  Interstitials must wait
 for a InterstitialAd.show() call.

Once an ad is requested, the adapter must report either success or failure.  If no response
 is heard within a time limit, the mediation library may move on to another adapter, resulting
 in a potentially successful ad not being shown.

From the point when this method is called until the adapter is destroyed,
 MediationInterstitialAdapter.showInterstitial() should open the interstitial.

Parameters:

adapter - The mediation adapter which raised the event.

See Also:

onFailedToReceiveAd(MediationInterstitialAdapter, AdRequest.ErrorCode)

onFailedToReceiveAd

void onFailedToReceiveAd(MediationInterstitialAdapter<?,?> adapter,
                       AdRequest.ErrorCode error)

Indicates that an ad request has failed along with the underlying cause.  A failure may be an
 actual error or just a lack of fill.

Once an ad is requested, the adapter must report either success or failure.  If no response
 is heard within a time limit, the mediation library may move on to another adapter, resulting
 in a potentially successful ad not being shown.

Parameters:

adapter - The mediation adapter which raised the event.

error - An error code detailing the cause of the failure.

See Also:

onReceivedAd(MediationInterstitialAdapter)

onPresentScreen

void onPresentScreen(MediationInterstitialAdapter<?,?> adapter)

Indicates that the ad control is rendering something that is full screen.  This may be an
 Activity, or it may be a precursor to switching to a different application.

Once this screen is dismissed, onDismissScreen(MediationInterstitialAdapter) must
 be called.

Parameters:

adapter - The mediation adapter which raised the event.

onDismissScreen

void onDismissScreen(MediationInterstitialAdapter<?,?> adapter)

Indicates that the ad control rendered something in full screen and is now transferring
 control back to the application.  This may be the user returning from a different application.

Parameters:

adapter - The mediation adapter which raised the event.

See Also:

onPresentScreen(MediationInterstitialAdapter)

onLeaveApplication

void onLeaveApplication(MediationInterstitialAdapter<?,?> adapter)

Indicates that the ad is causing the device to switch to a different application (such as a
 web browser).  This must be called before the current application is put in the background.

Parameters:

adapter - The mediation adapter which raised the event.

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:
package org.jboss.seam.example.messages.test;
import javax.faces.model.DataModel;

import java.io.File;

import org.jboss.shrinkwrap.api.Archive;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.importer.ZipImporter;
import org.jboss.shrinkwrap.api.spec.EnterpriseArchive;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.container.test.api.OverProtocol;
import org.jboss.arquillian.junit.Arquillian;

import org.jboss.seam.mock.JUnitSeamTest;

import org.junit.runner.RunWith;
import org.junit.Test;

@RunWith(Arquillian.class)
public class MessageListTest extends JUnitSeamTest
{
	@Deployment(name="MessageListTest")
	@OverProtocol("Servlet 3.0")
	public static Archive<?> createDeployment()
	{
      EnterpriseArchive er = ShrinkWrap.create(ZipImporter.class, "seam-messages.ear").importFrom(new File("../messages-ear/target/seam-messages.ear"))
				.as(EnterpriseArchive.class);
      WebArchive web = er.getAsType(WebArchive.class, "messages-web.war");
      web.addClasses(MessageListTest.class);

      // Install org.jboss.seam.mock.MockSeamListener
      web.delete("/WEB-INF/web.xml");
      web.addAsWebInfResource("web.xml");

      return er;
   }

   @Test
   public void testMessageList() throws Exception
   {
      new NonFacesRequest()
      {

         @Override
         protected void renderResponse() throws Exception {
            DataModel list = (DataModel) getInstance("messageList");
            assert list.getRowCount()==2;
         }

      }.run();

      new FacesRequest()
      {

         @Override
         protected void updateModelValues() throws Exception {
            DataModel list = (DataModel) getInstance("messageList");
            assert list.getRowCount()==2;
            list.setRowIndex(1);
         }

         @Override
         protected void invokeApplication() throws Exception {
            invokeMethod("#{messageManager.select}");
         }

         @Override
         protected void renderResponse() throws Exception {
            DataModel list = (DataModel) getInstance("messageList");
            assert list.getRowCount()==2;
            assert getValue("#{message.title}").equals("Hello World");
            assert getValue("#{message.read}").equals(true);
         }

      }.run();

      new FacesRequest()
      {

         @Override
         protected void updateModelValues() throws Exception {
            DataModel list = (DataModel) getInstance("messageList");
            assert list.getRowCount()==2;
            list.setRowIndex(0);
         }

         @Override
         protected void invokeApplication() throws Exception {
            invokeMethod("#{messageManager.delete}");
         }

         @Override
         protected void renderResponse() throws Exception {
            DataModel list = (DataModel) getInstance("messageList");
            assert list.getRowCount()==1;
         }

      }.run();

      new NonFacesRequest()
      {

         @Override
         protected void renderResponse() throws Exception {
            DataModel list = (DataModel) getInstance("messageList");
            assert list.getRowCount()==1;
         }

      }.run();

   }

}


text:
<?php
$url = 'https://www.radiozone.fr/';
$stations = array('80s', '90s', '00s', '10s');
$station = $stations[rand(0, count($stations)-1)];

$json = json_decode(file_get_contents($url.$station.'/meta'), true);
$cover = $json['current']['cover'];
$artist = $json['current']['artist'];
$title = $json['current']['title'];

$sentens = 'A l\'antenne de RadioZone '.ucfirst($station).' : '.$artist.' - '.$title;
$home_path = '/home/choiz/';
$display_width = 1920;
$display_height = 1080;
$font_size = 18;

if (file_exists('config.php')) {
    include_once('config.php');
}

$cover_width = 300;
$cover_height = 300;
$coef_width = $display_width / $cover_width;
$coef_height = $display_height / $cover_height;
$coef = $coef_height*100;
if ($coef_width>$coef_height) {
    $coef = $coef_width*100;
}
$cover_position = ($display_height - $cover_height)/2;
$text_position = ($display_height - $cover_height)/2 + $cover_height + ($font_size*2);

$coverurl = $url.'static/cover/'.$station.'/'.$cover;
exec('wget -q -O '.$home_path.'radiozone.jpg "'.$coverurl.'"');
sleep(1); // wait we get image
exec('convert '.$home_path.'radiozone.jpg '.$home_path.'radiozone.png');
exec('rm '.$home_path.'radiozone.jpg');
exec('convert -resize '.$coef.'% '.$home_path.'radiozone.png -alpha on -channel A -evaluate set 50% +channel -gravity center -extent '.$display_width.'x'.$display_height.' '.$home_path.'radiozoneBG.png');
exec('convert '.$home_path.'radiozone.png -alpha on \
            -gravity north -crop '.$display_width.'x'.$display_height.'+0-'.$cover_position.'\! \
                -background none -compose Over -flatten \
            -gravity south -fill black -pointsize '.$font_size.' -annotate +0+'.$text_position.' "'.$sentens.'" '.$home_path.'radiozone.png');
exec('convert '.$home_path.'radiozoneBG.png '.$home_path.'radiozone.png -gravity center -composite '.$home_path.'radiozone.png');
exec('rm '.$home_path.'radiozoneBG.png');


text:
namespace xla {
namespace util {
namespace {

hash_t SingleShapeHash(const Shape& shape, hash_t seed) {
  for (auto dim : shape.layout().minor_to_major()) {
    seed = HashCombine(seed, dim);
  }
  for (auto dim : shape.dimensions()) {
    seed = HashCombine(seed, dim);
  }
  return HashCombine(seed, static_cast<int>(shape.element_type()));
}

void MaybeSaveHloGraph(const std::string& hlo_text, size_t index) {
  static const std::string save_file =
      sys_util::GetEnvString("XLA_SAVE_HLO_FILE", "");
  if (!save_file.empty()) {
    static std::mutex lock;
    std::lock_guard<std::mutex> guard(lock);
    std::ofstream graph_file(save_file, std::ios_base::app);
    graph_file << "[HLO Graph " << index << " From Thread "
               << std::this_thread::get_id() << "]\n"
               << hlo_text << "\n";
  }
}

}  // namespace

StatusOr<std::unique_ptr<HloModule>> CreateModuleFromProto(
    const HloModuleProto& proto, const DebugOptions& debug_options) {
  TF_ASSIGN_OR_RETURN(
      auto hlo_module_config,
      HloModule::CreateModuleConfigFromProto(proto, debug_options));
  return HloModule::CreateFromProto(proto, hlo_module_config);
}

StatusOr<std::string> GetComputationHloText(const XlaComputation& computation) {
  TF_ASSIGN_OR_RETURN(auto hlo_module,
                      CreateModuleFromProto(computation.proto()));
  return hlo_module->ToString();
}

void ReportComputationError(
    const Status& status, absl::Span<const XlaComputation* const> computations,
    absl::Span<const Shape* const> output_shapes) {
  std::stringstream ss;
  for (size_t i = 0; i < computations.size(); ++i) {
    std::string hlo_text = GetComputationHloText(*computations[i]).ValueOrDie();
    MaybeSaveHloGraph(hlo_text, i);
    ss << ">>> Dumping Computation " << i << "\n";
    ss << hlo_text << "\n";
    if (i < output_shapes.size() && output_shapes[i] != nullptr) {
      ss << "OutputShape: " << *output_shapes[i] << "\n\n";
    }
  }
  ss << "StackTrace:\n" << tensorflow::CurrentStackTrace() << "\n";
  ss << "Status: " << status << "\n";
  XLA_LOG_LINES(tensorflow::ERROR, ss.str());
  TF_LOG(FATAL) << status.ToString();
}

void CheckComputationStatus(
    const Status& status, absl::Span<const XlaComputation* const> computations,
    absl::Span<const Shape* const> output_shapes) {
  if (!status.ok()) {
    ReportComputationError(status, computations, output_shapes);
  }
}

hash_t ShapeHash(const Shape& shape) {
  hash_t hash = 0xa5d2d6916;
  ShapeUtil::ForEachSubshape(shape,
                             [&](const Shape& subshape, const ShapeIndex&) {
                               hash = SingleShapeHash(subshape, hash);
                             });
  return hash;
}

}  // namespace util
}  // namespace xla


text:
#import "XCUIElement+FBIsVisible.h"

#import "XCElementSnapshot+Helpers.h"

@implementation XCUIElement (FBIsVisible)

- (BOOL)isFBVisible
{
  return self.lastSnapshot.isFBVisible;
}

@end

@implementation XCElementSnapshot (FBIsVisible)

- (BOOL)isFBVisible
{
  return [(NSNumber *)[self fb_attributeValue:FB_XCAXAIsVisibleAttribute] boolValue];
}

@end


text:
package portableDataExchange.serializer;

import com.gemstone.gemfire.pdx.PdxReader;
import com.gemstone.gemfire.pdx.PdxSerializer;
import com.gemstone.gemfire.pdx.PdxWriter;

/**
 * An example of a PdxSerializer that can serialize PositionPdx objects.
 * <p>
 *
 * @author GemStone Systems, Inc.
 * @since 6.6
 */
public class PositionSerializer implements PdxSerializer {

  /**
   * The fromData method deserializes this object using the given PDXReader.
   */
  @Override
  public Object fromData(Class<?> clazz, PdxReader reader) {
    if (!clazz.equals(PositionPdx.class)) {
      return null;
    }

    PositionPdx position = new PositionPdx();
    position.avg20DaysVol = reader.readLong("avg20DaysVol");
    position.bondRating = reader.readString("bondRating");
    position.convRatio = reader.readDouble("convRatio");
    position.country = reader.readString("country");
    position.delta = reader.readDouble("delta");
    position.industry = reader.readLong("industry");
    position.issuer = reader.readLong("issuer");
    position.mktValue = reader.readDouble("mktValue");
    position.qty = reader.readDouble("qty");
    position.secId = reader.readString("secId");
    position.secLinks = reader.readString("secLinks");
    position.secType = reader.readString("secType");
    position.sharesOutstanding = reader.readInt("sharesOutstanding");
    position.underlyer = reader.readString("underlyer");
    position.volatility = reader.readLong("volatility");
    position.pid = reader.readInt("pid");

    return position;
  }

  @Override
  public boolean toData(Object o, PdxWriter writer) {
    if (!(o instanceof PositionPdx)) {
      return false;
    }

    PositionPdx position = (PositionPdx) o;
    writer.writeLong("avg20DaysVol", position.avg20DaysVol);
    writer.writeString("bondRating", position.bondRating);
    writer.writeDouble("convRatio", position.convRatio);
    writer.writeString("country", position.country);
    writer.writeDouble("delta", position.delta);
    writer.writeLong("industry", position.industry);
    writer.writeLong("issuer", position.issuer);
    writer.writeDouble("mktValue", position.mktValue);
    writer.writeDouble("qty", position.qty);
    writer.writeString("secId", position.secId);
    writer.writeString("secLinks", position.secLinks);
    writer.writeString("secType", position.secType);
    writer.writeInt("sharesOutstanding", position.sharesOutstanding);
    writer.writeString("underlyer", position.underlyer);
    writer.writeLong("volatility", position.volatility);
    writer.writeInt("pid", position.pid);

    //Mark pid as an identity field.
    //objects serialized in pdx format can be read and modified while
    //remaining in serialized form. See the PdxInstance class.
    //PdxInstance objects use the identity fields in their equals and
    //hashCode implementations.
    writer.markIdentityField("pid");

    return true;
  }
}