text:
package org.pentaho.di.trans.steps.mysqlbulkloader;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.Date;

import org.pentaho.di.core.Const;
import org.pentaho.di.core.DBCache;
import org.pentaho.di.core.database.Database;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.row.RowMetaInterface;
import org.pentaho.di.core.row.ValueMeta;
import org.pentaho.di.core.row.ValueMetaInterface;
import org.pentaho.di.core.util.StreamLogger;
import org.pentaho.di.i18n.BaseMessages;
import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.step.BaseStep;
import org.pentaho.di.trans.step.StepDataInterface;
import org.pentaho.di.trans.step.StepInterface;
import org.pentaho.di.trans.step.StepMeta;
import org.pentaho.di.trans.step.StepMetaInterface;

/**
 * Performs a streaming bulk load to a MySQL table.
 *
 * Based on Sven Boden's Oracle Bulk Loader step
 *
 * @author matt
 * @since  14-apr-2009
 */
public class MySQLBulkLoader extends BaseStep implements StepInterface
{
	private static Class<?> PKG = MySQLBulkLoaderMeta.class; // for i18n purposes, needed by Translator2!!   $NON-NLS-1$

	private MySQLBulkLoaderMeta meta;
	private MySQLBulkLoaderData data;
	private final long threadWaitTime = 300000;
	private final String threadWaitTimeText = "5min";

	public MySQLBulkLoader(StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta, Trans trans)
	{
		super(stepMeta, stepDataInterface, copyNr, transMeta, trans);
	}

	public boolean execute(MySQLBulkLoaderMeta meta) throws KettleException
	{
        Runtime rt = Runtime.getRuntime();

        try
        {
        	// 1) Create the FIFO file using the "mkfifo" command...
        	//    Make sure to log all the possible output, also from STDERR
        	//
        	data.fifoFilename = environmentSubstitute(meta.getFifoFileName());

        	File fifoFile = new File(data.fifoFilename);
        	if (!fifoFile.exists()) {
        		// MKFIFO!
        		//
	        	String mkFifoCmd = "mkfifo "+data.fifoFilename;
	        	logBasic("Creating FIFO file using this command : "+mkFifoCmd);
	        	Process mkFifoProcess = rt.exec(mkFifoCmd);
	        	StreamLogger errorLogger = new StreamLogger(log, mkFifoProcess.getErrorStream(), "mkFifoError");
	        	StreamLogger outputLogger = new StreamLogger(log, mkFifoProcess.getInputStream(), "mkFifoOuptut");
	        	new Thread(errorLogger).start();
	        	new Thread(outputLogger).start();
	        	int result = mkFifoProcess.waitFor();
	        	if (result!=0) {
	        		throw new Exception("Return code "+result+" received from statement : "+mkFifoCmd);
	        	}

	        	String chmodCmd = "chmod 666 "+data.fifoFilename;
	        	logBasic("Setting FIFO file permissings using this command : "+chmodCmd);
	        	Process chmodProcess = rt.exec(chmodCmd);
	        	errorLogger = new StreamLogger(log, chmodProcess.getErrorStream(), "chmodError");
	        	outputLogger = new StreamLogger(log, chmodProcess.getInputStream(), "chmodOuptut");
	        	new Thread(errorLogger).start();
	        	new Thread(outputLogger).start();
	        	result = chmodProcess.waitFor();
	        	if (result!=0) {
	        		throw new Exception("Return code "+result+" received from statement : "+chmodCmd);
	        	}
        	}

        	// 2) Make a connection to MySQL for sending SQL commands
            // (Also, we need a clear cache for getting up-to-date target metadata)
            DBCache.getInstance().clear(meta.getDatabaseMeta().getName());
            if(meta.getDatabaseMeta()==null) {
        		logError(BaseMessages.getString(PKG, "MySQLBulkLoader.Init.ConnectionMissing", getStepname()));
        		return false;
        	}
			data.db = new Database(this, meta.getDatabaseMeta());
			data.db.shareVariablesWith(this);
			// Connect to the database
            if (getTransMeta().isUsingUniqueConnections())
            {
                synchronized (getTrans())
                {
                    data.db.connect(getTrans().getTransactionId(), getPartitionID());
                }
            } else
            {
                data.db.connect(getPartitionID());
            }

            logBasic("Connected to MySQL");

            // 3) Now we are ready to run the load command...
            //
            executeLoadCommand();
        }
        catch ( Exception ex )
        {
        	throw new KettleException(ex);
        }

        return true;
	}

  private void executeLoadCommand() throws Exception {

    String loadCommand = "";
    loadCommand += "LOAD DATA " + (meta.isLocalFile() ? "LOCAL" : "") + " INFILE '" + environmentSubstitute(meta.getFifoFileName()) + "' ";
    if (meta.isReplacingData()) {
      loadCommand += "REPLACE ";
    } else if (meta.isIgnoringErrors()) {
      loadCommand += "IGNORE ";
    }
    loadCommand += "INTO TABLE " + data.schemaTable + " ";
    if (!Const.isEmpty(meta.getEncoding())) {
      loadCommand += "CHARACTER SET " + meta.getEncoding() + " ";
    }
    String delStr = meta.getDelimiter();
    if ("\t".equals(delStr))
      delStr = "\\t";

    loadCommand += "FIELDS TERMINATED BY '" + delStr + "' ";
    if (!Const.isEmpty(meta.getEnclosure())) {
      loadCommand += "OPTIONALLY ENCLOSED BY '" + meta.getEnclosure() + "' ";
    }
    loadCommand += "ESCAPED BY '" + meta.getEscapeChar() + ("\\".equals(meta.getEscapeChar()) ? meta.getEscapeChar() : "") + "' ";

    // Build list of column names to set
    loadCommand += "(";
    for (int cnt = 0; cnt < meta.getFieldTable().length; cnt++) {
      loadCommand += meta.getDatabaseMeta().quoteField(meta.getFieldTable()[cnt]);
      if (cnt < meta.getFieldTable().length - 1)
        loadCommand += ",";
    }

    loadCommand += ");" + Const.CR;

    logBasic("Starting the MySQL bulk Load in a separate thread : " + loadCommand);
    data.sqlRunner = new SqlRunner(data, loadCommand);
    data.sqlRunner.start();

    // Ready to start writing rows to the FIFO file now...
    //
    if (!Const.isWindows()) {
      logBasic("Opening fifo " + data.fifoFilename + " for writing.");
      OpenFifo openFifo = new OpenFifo(data.fifoFilename, 1000);
      openFifo.start();

      // Wait for either the sql statement to throw an error or the
      // fifo writer to throw an error
      while (true) {
        openFifo.join(200);
        if (openFifo.getState() == Thread.State.TERMINATED)
          break;

        try {
          data.sqlRunner.checkExcn();
        } catch (Exception e) {
          // We need to open a stream to the fifo to unblock the fifo writer
          // that was waiting for the sqlRunner that now isn't running
          new BufferedInputStream(new FileInputStream(data.fifoFilename)).close();
          openFifo.join();
          logError("Make sure user has been granted the FILE privilege.");
          logError("");
          throw e;
        }

        try {
          openFifo.checkExcn();
        } catch (Exception e) {
          throw e;
        }
      }
      data.fifoStream = openFifo.getFifoStream();
    }

  }

	public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException
	{
		meta=(MySQLBulkLoaderMeta)smi;
		data=(MySQLBulkLoaderData)sdi;

		try
		{
			Object[] r=getRow();  // Get row from input rowset & set row busy!
			if (r==null)          // no more input to be expected...
			{
				setOutputDone();

				closeOutput();

				return false;
			}

			if (first)
			{
				first=false;

				// Cache field indexes.
				//
				data.keynrs = new int[meta.getFieldStream().length];
				for (int i=0;i<data.keynrs.length;i++) {
					data.keynrs[i] = getInputRowMeta().indexOfValue(meta.getFieldStream()[i]);
				}

				data.bulkFormatMeta = new ValueMetaInterface[data.keynrs.length];
				for (int i=0;i<data.keynrs.length;i++) {
					ValueMetaInterface sourceMeta = getInputRowMeta().getValueMeta(data.keynrs[i]);
					if (sourceMeta.isDate()) {
						if (meta.getFieldFormatType()[i]==MySQLBulkLoaderMeta.FIELD_FORMAT_TYPE_DATE) {
							data.bulkFormatMeta[i] = data.bulkDateMeta.clone();
						} else if (meta.getFieldFormatType()[i]==MySQLBulkLoaderMeta.FIELD_FORMAT_TYPE_TIMESTAMP) {
							data.bulkFormatMeta[i] = data.bulkTimestampMeta.clone(); // default to timestamp
						}
					} else if (sourceMeta.isNumeric() && meta.getFieldFormatType()[i]==MySQLBulkLoaderMeta.FIELD_FORMAT_TYPE_NUMBER) {
						data.bulkFormatMeta[i] = data.bulkNumberMeta.clone();
					}

					if (data.bulkFormatMeta[i]==null && !sourceMeta.isStorageBinaryString()) {
						data.bulkFormatMeta[i] = sourceMeta.clone();
					}
				}

				// execute the client statement...
				//
				execute(meta);
			}

			// Every nr of rows we re-start the bulk load process to allow indexes etc to fit into the MySQL server memory
			// Performance could degrade if we don't do this.
			//
			if (data.bulkSize>0 && getLinesOutput()>0 && (getLinesOutput()%data.bulkSize)==0) {
				closeOutput();
				executeLoadCommand();
			}

			writeRowToBulk(getInputRowMeta(), r);
			putRow(getInputRowMeta(), r);
			incrementLinesOutput();

			return true;
		}
		catch(Exception e)
		{
			logError(BaseMessages.getString(PKG, "MySQLBulkLoader.Log.ErrorInStep"), e); //$NON-NLS-1$
			setErrors(1);
			stopAll();
			setOutputDone();  // signal end to receiver(s)
			return false;
		}
	}

	private void closeOutput() throws Exception
	{

		if (data.fifoStream!=null) {
			// Close the fifo file...
			//
			data.fifoStream.close();
			data.fifoStream=null;
		}

		if (data.sqlRunner !=null) {

	        // wait for the INSERT statement to finish and check for any error and/or warning...
			logDebug("Waiting up to " + this.threadWaitTimeText + " for the MySQL load command thread to finish processing.");
	        data.sqlRunner.join(this.threadWaitTime);
	        SqlRunner sqlRunner = data.sqlRunner;
	        data.sqlRunner = null;
	        sqlRunner.checkExcn();
		}
	}

	private void writeRowToBulk(RowMetaInterface rowMeta, Object[] r) throws KettleException {

    	try {
	    	// So, we have this output stream to which we can write CSV data to.
	    	// Basically, what we need to do is write the binary data (from strings to it as part of this proof of concept)
	    	//
    		// The data format required is essentially:
    		//
    		for (int i=0;i<data.keynrs.length;i++) {
				if (i>0) {
		    		// Write a separator
		    		//
		    		data.fifoStream.write(data.separator);
				}

	    		int index = data.keynrs[i];
	    		ValueMetaInterface valueMeta = rowMeta.getValueMeta(index);
	    		Object valueData = r[index];

	    		if (valueData == null)
	    			data.fifoStream.write("NULL".getBytes());
	    		else
	    		{
		    		switch(valueMeta.getType()) {
		    		case ValueMetaInterface.TYPE_STRING :
		    			data.fifoStream.write(data.quote);
		    			if (valueMeta.isStorageBinaryString() && meta.getFieldFormatType()[i]==MySQLBulkLoaderMeta.FIELD_FORMAT_TYPE_OK) {
		    				// We had a string, just dump it back.
		    				data.fifoStream.write((byte[])valueData);
		    			} else {
		    				String string = valueMeta.getString(valueData);
		    				if (string!=null) {
			    				if (meta.getFieldFormatType()[i]==MySQLBulkLoaderMeta.FIELD_FORMAT_TYPE_STRING_ESCAPE) {
			    					string = Const.replace(string, meta.getEnclosure(), meta.getEscapeChar()+meta.getEnclosure());
			    				}
			    				data.fifoStream.write(string.getBytes());
		    				}
		    			}
		    			data.fifoStream.write(data.quote);
		    			break;
		    		case ValueMetaInterface.TYPE_INTEGER:
	    				if (valueMeta.isStorageBinaryString() && data.bulkFormatMeta[i]==null) {
	    					data.fifoStream.write( valueMeta.getBinaryString(valueData) );
	    				} else {
		    				Long integer = valueMeta.getInteger(valueData);
		    				if (integer!=null) {
		    					data.fifoStream.write(data.bulkFormatMeta[i].getString(integer).getBytes());
		    				}
	    				}
		    			break;
		    		case ValueMetaInterface.TYPE_DATE:
	    				if (valueMeta.isStorageBinaryString() && data.bulkFormatMeta[i]==null) {
	    					data.fifoStream.write( valueMeta.getBinaryString(valueData) );
	    				} else {
		    				Date date = valueMeta.getDate(valueData);
		    				if (date!=null) {
		    					data.fifoStream.write(data.bulkFormatMeta[i].getString(date).getBytes());
		    				}
	    				}
		    			break;
		    		case ValueMetaInterface.TYPE_BOOLEAN:
	    				if (valueMeta.isStorageBinaryString() && data.bulkFormatMeta[i]==null) {
	    					data.fifoStream.write( valueMeta.getBinaryString(valueData) );
	    				} else {
		    				Boolean b= valueMeta.getBoolean(valueData);
		    				if (b!=null) {
		    					data.fifoStream.write(data.bulkFormatMeta[i].getString(b).getBytes());
		    				}
	    				}
		    			break;
		    		case ValueMetaInterface.TYPE_NUMBER:
		    			if (valueMeta.isStorageBinaryString() && data.bulkFormatMeta[i]==null) {
		    				data.fifoStream.write((byte[])valueData);
		    			} else {
		    				Double d = valueMeta.getNumber(valueData);
		    				if (d!=null) {
		    					data.fifoStream.write(data.bulkFormatMeta[i].getString(d).getBytes());
		    				}
		    			}
		    			break;
		    		case ValueMetaInterface.TYPE_BIGNUMBER:
		    			if (valueMeta.isStorageBinaryString() && data.bulkFormatMeta[i]==null) {
		    				data.fifoStream.write((byte[])valueData);
		    			} else {
		    				BigDecimal bn = valueMeta.getBigNumber(valueData);
		    				if (bn!=null) {
		    					data.fifoStream.write(data.bulkFormatMeta[i].getString(bn).getBytes());
		    				}
		    			}
		    			break;
		    		}
	    		}
	    	}

			// finally write a newline
			//
    		data.fifoStream.write(data.newline);

    		if ((getLinesOutput()%5000)==0) {
    		  data.fifoStream.flush();
    		}
    	}
    	catch(IOException e)
    	{
    		// If something went wrong with writing to the fifo, get the underlying error from MySQL
    		try{
    			logError("IOException writing to fifo.  Waiting up to " + this.threadWaitTimeText + " for the MySQL load command thread to return with the error.");
    			try{ data.sqlRunner.join(this.threadWaitTime); }
    			catch (InterruptedException ex){}
    			data.sqlRunner.checkExcn();
    		}
    		catch (Exception loadEx){
    			throw new KettleException("Error serializing rows of data to the fifo file", loadEx);
    		}

			// MySQL didn't finish, throw the generic "Pipe" exception.
			throw new KettleException("Error serializing rows of data to the fifo file", e);

    	}
    	catch (Exception e2){
    		// Null pointer exceptions etc.
    		throw new KettleException("Error serializing rows of data to the fifo file", e2);
    	}
	}

	public boolean init(StepMetaInterface smi, StepDataInterface sdi)
	{
		meta=(MySQLBulkLoaderMeta)smi;
		data=(MySQLBulkLoaderData)sdi;

		if (super.init(smi, sdi))
		{
			if (Const.isEmpty(meta.getEnclosure())) {
				data.quote = new byte[] { };
			} else {
				data.quote = meta.getEnclosure().getBytes();
			}
			if (Const.isEmpty(meta.getDelimiter())) {
				data.separator = "\t".getBytes();
			} else {
				data.separator = meta.getDelimiter().getBytes();
			}
			data.newline = Const.CR.getBytes();

			data.bulkTimestampMeta = new ValueMeta("timestampMeta", ValueMetaInterface.TYPE_DATE);
			data.bulkTimestampMeta.setConversionMask("yyyy-MM-dd HH:mm:ss");
			data.bulkTimestampMeta.setStringEncoding(meta.getEncoding());

			data.bulkDateMeta = new ValueMeta("dateMeta", ValueMetaInterface.TYPE_DATE);
			data.bulkDateMeta.setConversionMask("yyyy-MM-dd");
			data.bulkDateMeta.setStringEncoding(meta.getEncoding());

			data.bulkNumberMeta = new ValueMeta("numberMeta", ValueMetaInterface.TYPE_NUMBER);
			data.bulkNumberMeta.setConversionMask("#.#");
			data.bulkNumberMeta.setGroupingSymbol(",");
			data.bulkNumberMeta.setDecimalSymbol(".");
			data.bulkNumberMeta.setStringEncoding(meta.getEncoding());

			data.bulkSize = Const.toLong(environmentSubstitute(meta.getBulkSize()), -1L);

			// Schema-table combination...
			data.schemaTable = meta.getDatabaseMeta().getQuotedSchemaTableCombination(environmentSubstitute(meta.getSchemaName()), environmentSubstitute(meta.getTableName()));

			return true;
		}
		return false;
	}

	public void dispose(StepMetaInterface smi, StepDataInterface sdi)
	{
	    meta = (MySQLBulkLoaderMeta)smi;
	    data = (MySQLBulkLoaderData)sdi;

	    // Close the output streams if still needed.
	    //
	    try {
	    	if (data.fifoStream!=null) {
	    		data.fifoStream.close();
	    	}

            // Stop the SQL execution thread
	    	//
            if (data.sqlRunner!= null) {
                data.sqlRunner.join();
                data.sqlRunner = null;
            }
            // Release the database connection
            //
            if (data.db!=null) {
                data.db.disconnect();
                data.db = null;
            }

            // remove the fifo file...
            //
            try {
            	if (data.fifoFilename!=null) {
            		new File(data.fifoFilename).delete();
            	}
            } catch(Exception e) {
            	logError("Unable to delete FIFO file : "+data.fifoFilename, e);
            }
	    }
	    catch(Exception e) {
	    	setErrors(1L);
	    	logError("Unexpected error encountered while closing the client connection", e);
	    }

	    super.dispose(smi, sdi);
	}

	// Class to try and open a writer to a fifo in a different thread.
	// Opening the fifo is a blocking call, so we need to check for errors
	// after a small waiting period
	static class OpenFifo extends Thread
	{
		private BufferedOutputStream fifoStream = null;
		private Exception ex;
		private String fifoName;
		private int size;

		OpenFifo(String fifoName, int size)
        {
			this.fifoName = fifoName;
			this.size = size;
        }

		public void run()
	    {
			try{
				fifoStream = new BufferedOutputStream( new FileOutputStream( OpenFifo.this.fifoName ), this.size );
			} catch (Exception ex) {
                this.ex = ex;
            }
        }

		void checkExcn() throws Exception
        {
            // This is called from the main thread context to rethrow any saved
            // excn.
            if (ex != null) {
                throw ex;
            }
        }

		BufferedOutputStream getFifoStream(){
			return fifoStream;
		}
	}

    static class SqlRunner extends Thread
    {
        private MySQLBulkLoaderData data;

        private String loadCommand;

        private Exception ex;

        SqlRunner(MySQLBulkLoaderData data, String loadCommand)
        {
            this.data = data;
            this.loadCommand = loadCommand;
        }

        public void run()
        {
            try {
                data.db.execStatement(loadCommand);
            } catch (Exception ex) {
                this.ex = ex;
            }
        }

        void checkExcn() throws Exception
        {
            // This is called from the main thread context to rethrow any saved
            // excn.
            if (ex != null) {
                throw ex;
            }
        }
    }
}


text:
> While this still works, it should be considered abandoned. Any PR issued will be accepted w/o question. If you want to own this repository, open an issue and contact me.

# Data Manager
[![Latest Version](https://img.shields.io/github/release/chrismichaels84/data-manager.svg?style=flat-square)](https://github.com/chrismichaels84/data-manager/releases)
[![Documentation Status](https://readthedocs.org/projects/data-manager/badge/?version=latest)](http://data-manager.readthedocs.io/en/latest/?badge=latest)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)
[![Build Status](https://img.shields.io/travis/chrismichaels84/data-manager/master.svg?style=flat-square)](https://travis-ci.org/chrismichaels84/data-manager)
[![Coverage Status](https://coveralls.io/repos/chrismichaels84/data-manager/badge.svg?branch=master)](https://coveralls.io/r/chrismichaels84/data-manager?branch=master)
[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/chrismichaels84/data-manager/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/chrismichaels84/data-manager/?branch=master)
[![Total Downloads](https://img.shields.io/packagist/dt/michaels/data-manager.svg?style=flat-square)](https://packagist.org/packages/michaels/data-manager)

[![SensioLabsInsight](https://insight.sensiolabs.com/projects/3ef3b9a4-6078-4ddf-bf0d-c84dac87f37a/big.png)](https://insight.sensiolabs.com/projects/3ef3b9a4-6078-4ddf-bf0d-c84dac87f37a)

Simple data manager for nested data, dot notation access, extendability, and container interoperability.

**[See Full Documentation](http://data-manager.readthedocs.io/en/latest/)**

## Goals
  * Light weight and fluent, simple, clear API
  * Manage nested data via dot-notation
  * Be [composable](docs/compose.md) - integrate into current containers via traits (extras)
  * Include extras for
    * [Loading Files](docs/load-files.md),
    * [Managing IoC](docs/ioc.md) / Dependencies.
  * Allow for protected data (immutable) and default values.
  * IoC container should:
    * Resolve via classes, factories, etc
    * Configure dependencies for dependencies,
    * Allow for fallbacks, preparing objects, and more.
  * Full test coverage, PSR compliant, [container interoperability](https://github.com/container-interop/container-interop), and best practices

## Install
Via Composer
``` bash
$ composer require michaels/data-manager
```

## Getting Started
Manager does exactly what you would expect: it *manages* complex items such as config data, arrays, and closures.
The best way to get started is simply instantiate `Michaels\Manager\Manager`

```php
$manager = new Michaels\Manager\Manager([
    'some' => [
        'starting' => [
            'data' => 'here (optional)'
        ]
    ]
]);
// Note, you may initialize Manager with an array or any instance of Traversable (like Manager itself)

/* Basic Usage. All works with dot notation as well */
$manager->add('name', 'value');
$manager->add('some.nested.data', 3); // Use dot notation for namespacing or nesting
$manager->get('name'); // 'value'
$manager->get('doesntexist', 'fallback'); // 'fallback'
$manager->get('doesntexist') // throws an ItemNotFoundException with no fallback
$manager->getIfHas('doesntexist') // returns a NoItemFoundMessage instead of a script-stopping exception
$manager->getAll(); // returns array of all items
$manager->all(); // returns array of all items
$manager->exists('name'); // true
$manager->exists('some.starting.data'); // true
$manager->exists('nope'); // false
$manager->has('something'); // alias of exist
$manager->set('name', 'new-value'); // updates item
$manager->remove('some.starting.data');
$manager->isEmpty(); // true or false
$manager->toJson(); // returns json of all items
echo $manager; // returns json string of all items
$manager->reset($array); // rebuild with new items
$manager->clear(); // empty the manager

/* You can also use $manager as an array or in loops */
$manager['some']['starting']['data']; // 'here (optional)'
//etc

foreach ($manager as $item => $value) {
    // do whatever your heart desires
}

/* You may also push elements onto an array */
$manager->set('a.b', []);
$manager->push('a.b', 'c', 'd', 'e');
$manager->get('a.b'); // ['c', 'd', 'e']

/* Finally, you may manage values using magic methods */
$manager->some()->starting()->data; // 'here (optional)'
$manager->some()->item = 'item'; // sets some.item = 'item'
$manager->some()->item()->drop(); // deletes some.item

// Note that levels are called as a method with no params. The data is then called, updated, or set as a property.
```

## Advanced Features
See [documentation](http://data-manager.readthedocs.io/en/latest/) for topics like protecting data, using as an ioc container, loading files, using as an array, defaults, composing, and more.

## Interoperability
Data Manager is [PSR compliant](http://www.php-fig.org/) and [Container Interoperability](https://github.com/container-interop/container-interop) compliant. Any oversights, please let me know.

## Testing
We try for at least 80% test coverage.
``` bash
$ phpunit
```

You may also use the **tests** under `tests/traits` to test your integrated functionality. You may have to grab these through cloning the repo. composer usually won't include tests in your `require`

## Contributing
Contributions are welcome and will be fully credited. Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

## Security
If you discover any security related issues, please email chrismichaels84@gmail.com instead of using the issue tracker.

## Credits
- [Michael Wilson](https://github.com/chrismichaels84)
- [Scott](https://github.com/smolinari)
- Open an issue to join in!

## License
The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

redpajama_set_name: RedPajamaGithub


text:
using UnityEngine;
using System.Collections;
using System;

/// <summary>
/// Game Jolt API Helper main class. Inherit from <see cref="MonoBehaviour"/>
/// </summary>
public class GJAPIHelper : MonoBehaviour {

	#region Singleton Pattern
	/// <summary>
	/// The GJAPIHelper instance.
	/// </summary>
	private static GJAPIHelper instance;
	/// <summary>
	/// Gets the GJAPIHelper instance.
	/// </summary>
	/// <value>
	/// The GJAPIHelper instance.
	/// </value>
	public static GJAPIHelper Instance
	{
		get
		{
			if (instance == null)
			{
				GJAPI gjapi = (GJAPI) FindObjectOfType (typeof (GJAPI));

				if (gjapi == null)
				{
					Debug.LogError ("An instance of GJAPI is needed in the scene, but there is none. Can't initialise GJAPIHelper.");
				}
				else
				{
					instance = gjapi.gameObject.AddComponent<GJAPIHelper>();

					if (instance == null)
					{
						Debug.Log ("An error occured creating GJAPIHelper.");
					}
					else
					{
						instance.skin = (GUISkin) Resources.Load ("GJSkin", typeof (GUISkin)) ?? GUI.skin;
					}
				}
			}

			return instance;
		}
	}

	/// <summary>
	/// Releases unmanaged resources and performs other cleanup operations before the application quit.
	/// </summary>
	void OnApplicationQuit ()
	{
		StopAllCoroutines ();
		skin = null;
		users = null;
		scores = null;
		trophies = null;
		instance = null;
	}
	#endregion Singleton Pattern

	/// <summary>
	/// The <see cref="GUISkin"/>.
	/// </summary>
	protected GUISkin skin = null;
	/// <summary>
	/// Gets or sets the <see cref="GUISkin"/>.
	/// </summary>
	/// <value>
	/// The <see cref="GUISkin"/>.
	/// </value>
	public static GUISkin Skin
	{
		get { return Instance.skin; }
		set { Instance.skin = value; }
	}

	/// <summary>
	/// The users helpers.
	/// </summary>
	GJHUsersMethods users = null;
	/// <summary>
	/// Gets the users helpers.
	/// </summary>
	/// <value>
	/// The users helpers.
	/// </value>
	public static GJHUsersMethods Users
	{
		get
		{
			if (Instance.users == null)
			{
				Instance.users = new GJHUsersMethods ();
			}

			return Instance.users;
		}
	}

	/// <summary>
	/// The scores helpers.
	/// </summary>
	GJHScoresMethods scores = null;
	/// <summary>
	/// Gets the scores helpers.
	/// </summary>
	/// <value>
	/// The scores helpers.
	/// </value>
	public static GJHScoresMethods Scores
	{
		get
		{
			if (Instance.scores == null)
			{
				Instance.scores = new GJHScoresMethods ();
			}

			return Instance.scores;
		}
	}

	/// <summary>
	/// The trophies helpers.
	/// </summary>
	GJHTrophiesMethods trophies = null;
	/// <summary>
	/// Gets the trophies helpers.
	/// </summary>
	/// <value>
	/// The trophies helpers.
	/// </value>
	public static GJHTrophiesMethods Trophies
	{
		get
		{
			if (Instance.trophies == null)
			{
				Instance.trophies = new GJHTrophiesMethods ();
			}

			return Instance.trophies;
		}
	}

	/// <summary>
	/// Downloads the image.
	/// </summary>
	/// <param name='url'>
	/// The image URL.
	/// </param>
	/// <param name='OnComplete'>
	/// The callback.
	/// </param>
	public static void DownloadImage (string url, Action<Texture2D> OnComplete)
	{
		Instance.StartCoroutine (Instance.DownloadImageCoroutine (url, OnComplete));
	}

	/// <summary>
	/// Downloads the image coroutine.
	/// </summary>
	/// <param name='url'>
	/// The image URL.
	/// </param>
	/// <param name='OnComplete'>
	/// The callback.
	/// </param>
	IEnumerator DownloadImageCoroutine (string url, Action<Texture2D> OnComplete)
	{
		if (!string.IsNullOrEmpty (url))
		{
			Texture2D tex;
			WWW www = new WWW (url);
			yield return www;

			if (www.error == null)
			{
				tex = new Texture2D (1, 1, TextureFormat.RGB24, false);
				tex.LoadImage (www.bytes);
				tex.wrapMode = TextureWrapMode.Clamp;
			}
			else
			{
				Debug.Log ("GJAPIHelper: Error downloading image:\n" + www.error);
				tex = null;
			}

			if (OnComplete != null)
			{
				OnComplete (tex);
			}
		}
	}

	public void OnGetUserFromWeb (string response)
	{
		users.ReadGetFromWebResponse (response);
	}
}


text:
#ifndef TRIE_H
#define TRIE_H

#include <cassert>
#include <climits>
#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;

namespace preasp {

class Node {

    public:
        inline Node(int content_for_node) : content(content_for_node), label(UINT_MAX){}
        inline ~Node() { for( unordered_map<int, Node*>::iterator it = childrenMap.begin(); it != childrenMap.end(); ++it ) { assert( it->second ); delete it->second; } }

        inline int getContent() const { return content; }
        inline bool hasLabel() const { return label != UINT_MAX; }
        inline unsigned int getLabel() const { return label; }
        inline void setLabel( unsigned int l ) { label = l; }

        Node* findChild(int c) {
            if(childrenMap.find(c) != childrenMap.end()) return childrenMap[ c ];
            return NULL;
        }

        inline void addChild(Node* child) { assert( childrenMap.find( child->getContent() ) == childrenMap.end() ); childrenMap[ child->getContent() ] = child; }

    private:
        int content;
        unsigned int label;
        unordered_map< int, Node* > childrenMap;
};

class Trie {
    public:
        Trie() : current(NULL), numberOfLabels(0), disabled(0) { root = new Node( UINT_MAX ); }
        ~Trie() { clear(); }

        inline void clear() { delete root; root = NULL; }
        inline void disable() { if(disabled) return; clear(); disabled = 1; }
        inline void setNumberOfLabels(unsigned int nbOfLabels) { numberOfLabels = nbOfLabels; }
        inline void startInsertion() { if(!disabled) { assert(current == NULL); current = root; } }

        inline bool addElement(int element) {
            if(disabled) return false;
            assert(current != NULL);
            Node* node = current->findChild(element);
            if(node == NULL) { node = new Node(element); current->addChild(node); }
            assert(node != NULL);
            current = node;
            return current->hasLabel();
        }

        inline unsigned int getLabel() const { return current->getLabel(); }

        inline bool endInsertion() {
            if(disabled) return false;
            assert(current != NULL);
            bool tmp = true;
            if(!current->hasLabel()) { current->setLabel( ++numberOfLabels ); tmp = false; }
            current = NULL;
            return tmp;
        }

        inline unsigned int endInsertionGetLabel() {
            if(disabled) return false;
            assert(current != NULL);
            unsigned int label = current->getLabel();
            if(!current->hasLabel()) { current->setLabel( ++numberOfLabels ); }
            current = NULL;
            return label;
        }

    private:
        Node* root;
        Node* current;
        unsigned int numberOfLabels : 31;
        unsigned int disabled : 1;
        inline Trie(const Trie& orig);
};

}

#endif


text:
<?php

use Illuminate\Encryption\Encrypter;

class EncrypterTest extends PHPUnit_Framework_TestCase
{
    public function testEncryption()
    {
        $e = new Encrypter(str_repeat('a', 16));
        $encrypted = $e->encrypt('foo');
        $this->assertNotEquals('foo', $encrypted);
        $this->assertEquals('foo', $e->decrypt($encrypted));
    }

    public function testWithCustomCipher()
    {
        $e = new Encrypter(str_repeat('b', 32), 'AES-256-CBC');
        $encrypted = $e->encrypt('bar');
        $this->assertNotEquals('bar', $encrypted);
        $this->assertEquals('bar', $e->decrypt($encrypted));
    }

    /**
     * @expectedException RuntimeException
     * @expectedExceptionMessage The only supported ciphers are AES-128-CBC and AES-256-CBC with the correct key lengths.
     */
    public function testDoNoAllowLongerKey()
    {
        new Encrypter(str_repeat('z', 32));
    }

    /**
     * @expectedException RuntimeException
     * @expectedExceptionMessage The only supported ciphers are AES-128-CBC and AES-256-CBC with the correct key lengths.
     */
    public function testWithBadKeyLength()
    {
        new Encrypter(str_repeat('a', 5));
    }

    /**
     * @expectedException RuntimeException
     * @expectedExceptionMessage The only supported ciphers are AES-128-CBC and AES-256-CBC with the correct key lengths.
     */
    public function testWithBadKeyLengthAlternativeCipher()
    {
        new Encrypter(str_repeat('a', 16), 'AES-256-CFB8');
    }

    /**
     * @expectedException RuntimeException
     * @expectedExceptionMessage The only supported ciphers are AES-128-CBC and AES-256-CBC with the correct key lengths.
     */
    public function testWithUnsupportedCipher()
    {
        new Encrypter(str_repeat('c', 16), 'AES-256-CFB8');
    }

    /**
     * @expectedException Illuminate\Contracts\Encryption\DecryptException
     * @expectedExceptionMessage The payload is invalid.
     */
    public function testExceptionThrownWhenPayloadIsInvalid()
    {
        $e = new Encrypter(str_repeat('a', 16));
        $payload = $e->encrypt('foo');
        $payload = str_shuffle($payload);
        $e->decrypt($payload);
    }

    /**
     * @expectedException Illuminate\Contracts\Encryption\DecryptException
     * @expectedExceptionMessage The MAC is invalid.
     */
    public function testExceptionThrownWithDifferentKey()
    {
        $a = new Encrypter(str_repeat('a', 16));
        $b = new Encrypter(str_repeat('b', 16));
        $b->decrypt($a->encrypt('baz'));
    }
}


text:
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>operator==</title>
    <link rel="stylesheet" href="apiReference.css" type="text/css" />
    <meta name="generator" content="DocBook XSL Stylesheets V1.73.2" />
    <link rel="start" href="index.html" title="Berkeley DB C++ Standard Template Library API Reference" />
    <link rel="up" href="BulkRetrievalOption.html" title="Chapter 27.  BulkRetrievalOption" />
    <link rel="prev" href="BulkRetrievalOption.html" title="Chapter 27.  BulkRetrievalOption" />
    <link rel="next" href="stlBulkRetrievalOptionoperator_assign.html" title="operator=" />

Library Version 11.2.5.3

          operator==

          Prev
          Chapter 27.
 BulkRetrievalOption
           Next

operator==

Function Details

bool operator==(const BulkRetrievalOption &bro) const

Equality comparison.

Class

  BulkRetrievalOption

          Prev

            Up

           Next

          Chapter 27.
 BulkRetrievalOption

            Home

           operator=


text:
package com.yammer.backups.policy;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.dropwizard.util.Duration;

import javax.validation.constraints.Min;

public class RetentionPolicyConfiguration {

    @JsonProperty
    private final Duration minDuration;

    @JsonProperty
    @Min(0)
    private final int minCount;

    @JsonProperty
    @Min(0)
    private final int daily;

    @JsonProperty
    @Min(0)
    private final int weekly;

    @JsonProperty
    @Min(0)
    private final int monthly;

    @JsonProperty
    @Min(0)
    private final int yearly;

    @JsonCreator
    public RetentionPolicyConfiguration(
            @JsonProperty("minDuration") Duration minDuration,
            @JsonProperty("minCount") int minCount,
            @JsonProperty("daily") int daily,
            @JsonProperty("weekly") int weekly,
            @JsonProperty("monthly") int monthly,
            @JsonProperty("yearly") int yearly) {
        this.minDuration = minDuration;
        this.minCount = minCount;
        this.daily = daily;
        this.weekly = weekly;
        this.monthly = monthly;
        this.yearly = yearly;
    }

    public Duration getMinDuration() {
        return minDuration;
    }

    public int getMinCount() {
        return minCount;
    }

    public int getDaily() {
        return daily;
    }

    public int getWeekly() {
        return weekly;
    }

    public int getMonthly() {
        return monthly;
    }

    public int getYearly() {
        return yearly;
    }
}


text:
<?php
if ($action == 'update' && is_array($update_carriers)) {
    foreach($update_carriers as $k=>$v) {
        if ($k == 0) {
            if ($v['carrier']) {
                $v['addon'] = '';
                cw_shipping_insert_carrier($v);
            }
        }
        else
            cw_shipping_update_carrier($k, $v);
    }
    cw_header_location('index.php?target='.$target);
}

if ($action == 'delete' && is_array($del_carriers)) {
    foreach($del_carriers as $k=>$v)
        cw_shipping_delete_carrier($k);
    cw_header_location('index.php?target='.$target);
}

$carriers = cw_shipping_get_carriers(true);
$smarty->assign('carriers', $carriers);

$location[] = array(cw_get_langvar_by_name('lbl_carriers'), '');
$smarty->assign('current_main_dir', 'addons/shipping_system');
$smarty->assign('current_section_dir', 'admin');
$smarty->assign('main', 'carriers');


text:
order: 2
---

## Create your first Kitura app

Ready to go? Try the Hello World tutorial.

[Try the Tutorial](/docs/getting-started/hello-world)


text:
<html>
  <head>
    <script src="register_conversion.js"></script>
    <script src="register_attribution_src.js"></script>
  </head>
  This page has a script which creates images that redirect to the conversion registration endpoint.
</html>


text:
var assert = require('assert');
var common = require('../../common');
var pool   = common.createPool({debug: true, port: common.fakeServerPort});
var util   = require('util');

var tid    = 0;
var server = common.createFakeServer();

server.listen(common.fakeServerPort, function (err) {
  assert.ifError(err);

  var messages = [];

  console.log = function () {
    var msg = util.format.apply(this, arguments);
    if (String(msg).indexOf('--') !== -1) {
      messages.push(msg.split(' {')[0]);
    }
  };

  pool.getConnection(function (err, conn1) {
    assert.ifError(err);
    conn1.query('SELECT 1', function (err) {
      assert.ifError(err);
      pool.getConnection(function (err, conn2) {
        assert.ifError(err);
        conn2.query('SELECT 1', function (err) {
          assert.ifError(err);
          conn1.release();
          conn2.release();
          pool.end(function (err) {
            assert.ifError(err);
            assert.equal(messages.length, 20);
            assert.deepEqual(messages, [
              '<-- HandshakeInitializationPacket',
              '--> (1) ClientAuthenticationPacket',
              '<-- (1) OkPacket',
              '--> (1) ComQueryPacket',
              '<-- (1) ResultSetHeaderPacket',
              '<-- (1) FieldPacket',
              '<-- (1) EofPacket',
              '<-- (1) RowDataPacket',
              '<-- (1) EofPacket',
              '<-- HandshakeInitializationPacket',
              '--> (2) ClientAuthenticationPacket',
              '<-- (2) OkPacket',
              '--> (2) ComQueryPacket',
              '<-- (2) ResultSetHeaderPacket',
              '<-- (2) FieldPacket',
              '<-- (2) EofPacket',
              '<-- (2) RowDataPacket',
              '<-- (2) EofPacket',
              '--> (1) ComQuitPacket',
              '--> (2) ComQuitPacket'
            ]);

            server.destroy();
          });
        });
      });
    });
  });
});

server.on('connection', function (conn) {
  conn.handshake({ threadId: ++tid });
});


text:
  Charny-sur-Meuse est
       un village
       localisé dans le département de Meuse en Lorraine. Elle comptait 543 habitants en 2008.

La ville compte quelques  aménagements, elle dispose, entre autres, de un terrain de sport.

Si vous envisagez de demenager à Charny-sur-Meuse, vous pourrez aisément trouver une maison à vendre.

Le nombre d'habitations, à Charny-sur-Meuse, était réparti en 2011 en 15 appartements et 217 maisons soit
 un marché relativement équilibré.

À Charny-sur-Meuse, la valeur moyenne à l'achat d'un appartement s'évalue à zero € du m² en vente. Le prix moyen d'une maison à l'achat se situe à 1 840 € du m². À la location la valeur moyenne se situe à 0 € du m² par mois.

À coté de Charny-sur-Meuse sont positionnées géographiquement les communes de
Bras-sur-Meuse localisée à 1 km, 686 habitants,
Champneuville située à 4 km, 114 habitants,
Douaumont située à 5 km, sept habitants,
Vacherauville à 1 km, 111 habitants,
Regnéville-sur-Meuse localisée à 5 km, 39 habitants,
Samogneux à 5 km, 67 habitants,
 entre autres. De plus, Charny-sur-Meuse est située à seulement cinq km de Verdun.


text:
{% block title %}{{ title }}{% endblock %}

{% block header %}{{ title }}{% endblock %}

{% block content %}

		{{ message }}

{% endblock %}


text: package com.github.ckwen.je.shiro.test;


text:
var common = require("../../common/js/common.js");
var curVideoList = [], curPage = 1;
var app = getApp();
Page({
  data: {
    video_list: []
  },
  onLoad: function (param) {
    curVideoList = [];
    curPage = 1;
    wx.setNavigationBarTitle({
      title: param.BarTitle
    });
  },
  onReady: function () {
    this.queryVideoList(curPage);
  },
  queryVideoList: function (page) {
    var that = this;
    common.requestServer("p=course&ac=vcourse&d=getVcoursesParam&isNeadPager=true", { "pindex": page, "psize": 3 }, function (data) {
      if (data.length == 0) {
        if (page == 1) {
          that.setData({
            video_list: [],
            loading: {
              status: true,
              load: false,
              text: "暂无数据"
            }
          });
        } else {
          that.setData({
            loading: {
              status: true,
              load: false,
              text: "没有更多数据"
            }
          });
          curPage--;
        }
      } else {
        data.forEach(function (item) {
          var temp = {
            title: item.name,
            sub_title: item.breif,
            tag: "",
            duration: "",
            id: item.id,
            poster_src: item.picarr,
            price: item.price,
            ischarge: item.ischarge,
            xnumber: item.xnumber
          }
          curVideoList.push(temp);
        });
        that.setData({
          video_list: curVideoList,
          loading: {
            status: false,
            load: false,
            text: ""
          }
        });
      }
    })
  },
  ToVideoDetail: function (event) {
    var dataSet = event.currentTarget.dataset;
    wx.navigateTo({
      url: '../course_detail/course_detail?id=' + dataSet.videoId + '&BarTitle=' + dataSet.videoName + '&price=' + dataSet.videoPrice + '&ischarge=' + dataSet.videoIscharge + '&xnumber=' + dataSet.videoXnumber
    })
  },
  onReachBottom: function () {
    this.setData({
      loading: {
        status: true,
        load: true,
        text: "加载中..."
      }
    });
    curPage++;
    this.queryVideoList(curPage);
  },
  formSubmit: function (event) {
    var formId = event.detail.formId;
    var dataSet = event.detail.target.dataset;
    wx.navigateTo({
      url: '../course_detail/course_detail?id=' + dataSet.videoId + '&BarTitle=' + dataSet.videoName + '&price=' + dataSet.videoPrice + '&ischarge=' + dataSet.videoIscharge + '&xnumber=' + dataSet.videoXnumber
    })
    common.requestServer("p=member&ac=formid&d=saveFormidParam", { "memberid": app.memberid, "formid": formId });
  }
})


text:
package some.test;

import org.bson.types.Decimal128;
import org.bson.types.ObjectId;

import java.util.Date;
import java.util.UUID;

import io.realm.RealmAny;
import io.realm.MutableRealmInteger;
import io.realm.RealmDictionary;
import io.realm.RealmList;
import io.realm.RealmObject;
import io.realm.RealmResults;
import io.realm.annotations.LinkingObjects;
import io.realm.annotations.PrimaryKey;
import io.realm.annotations.Required;

public class AllTypes extends RealmObject {

    public static final String TAG = "AllTypes";
    public static final String FIELD_PARENTS = "columnObject";

    @PrimaryKey
    private String columnString;

    private long columnLong;
    private float columnFloat;
    private double columnDouble;
    private boolean columnBoolean;
    @Required
    private Decimal128 columnDecimal128;
    @Required
    private ObjectId columnObjectId;
    @Required
    private UUID columnUUID;

    @Required
    private Date columnDate;

    private RealmAny columnRealmAny;

    @Required
    private byte[] columnBinary;

    private final MutableRealmInteger columnMutableRealmInteger = MutableRealmInteger.valueOf(0);

    private AllTypes columnObject;
    private Simple columnObjectWithoutPk;

    private RealmList<AllTypes> columnRealmList;
    private RealmList<Simple> columnRealmListNoPk;

    private final RealmList<AllTypes> columnRealmFinalList = new RealmList<>();
    private final RealmList<Simple> columnRealmFinalListNoPk = new RealmList<>();

    private RealmList<String> columnStringList;
    private RealmList<byte[]> columnBinaryList;
    private RealmList<Boolean> columnBooleanList;
    private RealmList<Long> columnLongList;
    private RealmList<Integer> columnIntegerList;
    private RealmList<Short> columnShortList;
    private RealmList<Byte> columnByteList;
    private RealmList<Double> columnDoubleList;
    private RealmList<Float> columnFloatList;
    private RealmList<Date> columnDateList;
    private RealmList<Decimal128> columnDecimal128List;
    private RealmList<ObjectId> columnObjectIdList;
    private RealmList<UUID> columnUUIDList;
    private RealmList<RealmAny> columnRealmAnyList;

    private RealmDictionary<AllTypes> columnRealmDictionary;

    private RealmDictionary<Boolean> columnBooleanDictionary;
    private RealmDictionary<String> columnStringDictionary;
    private RealmDictionary<Integer> columnIntegerDictionary;
    private RealmDictionary<Float> columnFloatDictionary;
    private RealmDictionary<Long> columnLongDictionary;
    private RealmDictionary<Short> columnShortDictionary;
    private RealmDictionary<Double> columnDoubleDictionary;
    private RealmDictionary<Byte> columnByteDictionary;
    private RealmDictionary<byte[]> columnBinaryDictionary;
    private RealmDictionary<Date> columnDateDictionary;
    private RealmDictionary<ObjectId> columnObjectIdDictionary;
    private RealmDictionary<UUID> columnUUIDDictionary;
    private RealmDictionary<Decimal128> columnDecimal128Dictionary;
    private RealmDictionary<RealmAny> columnRealmAnyDictionary;

    @LinkingObjects(FIELD_PARENTS)
    private final RealmResults<AllTypes> parentObjects = null;

    public String getColumnString() {
        return realmGet$columnString();
    }

    public void setColumnString(String columnString) {
        realmSet$columnString(columnString);
    }

    public String realmGet$columnString() {
        return columnString;
    }

    public void realmSet$columnString(String columnString) {
        this.columnString = columnString;
    }

    public long getColumnLong() {
        return realmGet$columnLong();
    }

    public void setColumnLong(long columnLong) {
        realmSet$columnLong(columnLong);
    }

    public long realmGet$columnLong() {
        return columnLong;
    }

    public void realmSet$columnLong(long columnLong) {
        this.columnLong = columnLong;
    }

    public float getColumnFloat() {
        return realmGet$columnFloat();
    }

    public void setColumnFloat(float columnFloat) {
        realmSet$columnFloat(columnFloat);
    }

    public float realmGet$columnFloat() {
        return columnFloat;
    }

    public void realmSet$columnFloat(float columnFloat) {
        this.columnFloat = columnFloat;
    }

    public double getColumnDouble() {
        return realmGet$columnDouble();
    }

    public void setColumnDouble(double columnDouble) {
        realmSet$columnDouble(columnDouble);
    }

    public double realmGet$columnDouble() {
        return columnDouble;
    }

    public void realmSet$columnDouble(double columnDouble) {
        this.columnDouble = columnDouble;
    }

    public boolean isColumnBoolean() {
        return realmGet$columnBoolean();
    }

    public void setColumnBoolean(boolean columnBoolean) {
        realmSet$columnBoolean(columnBoolean);
    }

    public boolean realmGet$columnBoolean() {
        return columnBoolean;
    }

    public void realmSet$columnBoolean(boolean columnBoolean) {
        this.columnBoolean = columnBoolean;
    }

    public Date getColumnDate() {
        return realmGet$columnDate();
    }

    public void setColumnDate(Date columnDate) {
        realmSet$columnDate(columnDate);
    }

    public Date realmGet$columnDate() {
        return columnDate;
    }

    public void realmSet$columnDate(Date columnDate) {
        this.columnDate = columnDate;
    }

    public byte[] getColumnBinary() {
        return realmGet$columnBinary();
    }

    public void setColumnBinary(byte[] columnBinary) {
        realmSet$columnBinary(columnBinary);
    }

    public byte[] realmGet$columnBinary() {
        return columnBinary;
    }

    public void realmSet$columnBinary(byte[] columnBinary) {
        this.columnBinary = columnBinary;
    }

    public AllTypes getColumnObject() {
        return realmGet$columnObject();
    }

    public void setColumnObject(AllTypes columnObject) {
        realmSet$columnObject(columnObject);
    }

    public AllTypes realmGet$columnObject() {
        return columnObject;
    }

    public void realmSet$columnObject(AllTypes columnObject) {
        this.columnObject = columnObject;
    }

    public RealmList<AllTypes> getColumnRealmList() {
        return realmGet$columnRealmList();
    }

    public void setColumnRealmList(RealmList<AllTypes> columnRealmList) {
        realmSet$columnRealmList(columnRealmList);
    }

    public RealmList<AllTypes> realmGet$columnRealmList() {
        return columnRealmList;
    }

    public void realmSet$columnRealmList(RealmList<AllTypes> columnRealmList) {
        this.columnRealmList = columnRealmList;
    }

    public MutableRealmInteger getColumnMutableRealmInteger() {
        return realmGet$columnMutableRealmInteger();
    }

    public MutableRealmInteger realmGet$columnMutableRealmInteger() {
        return columnMutableRealmInteger;
    }

    public RealmAny getColumnRealmAny() {
        return realmGet$columnRealmAny();
    }

    public RealmAny realmGet$columnRealmAny() {
        return columnRealmAny;
    }

    public RealmDictionary<AllTypes> getColumnRealmDictionary() {
        return columnRealmDictionary;
    }

    public void setColumnRealmDictionary(RealmDictionary<AllTypes> columnRealmDictionary) {
        this.columnRealmDictionary = columnRealmDictionary;
    }

    public RealmDictionary<Boolean> getColumnBooleanDictionary() {
        return columnBooleanDictionary;
    }

    public void setColumnBooleanDictionary(RealmDictionary<Boolean> columnBooleanDictionary) {
        this.columnBooleanDictionary = columnBooleanDictionary;
    }

    public RealmDictionary<String> getColumnStringDictionary() {
        return columnStringDictionary;
    }

    public void setColumnStringDictionary(RealmDictionary<String> columnStringDictionary) {
        this.columnStringDictionary = columnStringDictionary;
    }

    public RealmDictionary<Integer> getColumnIntegerDictionary() {
        return columnIntegerDictionary;
    }

    public void setColumnIntegerDictionary(RealmDictionary<Integer> columnIntegerDictionary) {
        this.columnIntegerDictionary = columnIntegerDictionary;
    }

    public RealmDictionary<Float> getColumnFloatDictionary() {
        return columnFloatDictionary;
    }

    public void setColumnFloatDictionary(RealmDictionary<Float> columnFloatDictionary) {
        this.columnFloatDictionary = columnFloatDictionary;
    }

    public RealmDictionary<Long> getColumnLongDictionary() {
        return columnLongDictionary;
    }

    public void setColumnLongDictionary(RealmDictionary<Long> columnLongDictionary) {
        this.columnLongDictionary = columnLongDictionary;
    }

    public RealmDictionary<Short> getColumnShortDictionary() {
        return columnShortDictionary;
    }

    public void setColumnShortDictionary(RealmDictionary<Short> columnShortDictionary) {
        this.columnShortDictionary = columnShortDictionary;
    }

    public RealmDictionary<Double> getColumnDoubleDictionary() {
        return columnDoubleDictionary;
    }

    public void setColumnDoubleDictionary(RealmDictionary<Double> columnDoubleDictionary) {
        this.columnDoubleDictionary = columnDoubleDictionary;
    }

    public RealmDictionary<Byte> getColumnByteDictionary() {
        return columnByteDictionary;
    }

    public void setColumnByteDictionary(RealmDictionary<Byte> columnByteDictionary) {
        this.columnByteDictionary = columnByteDictionary;
    }

    public RealmDictionary<byte[]> getColumnBinaryDictionary() {
        return columnBinaryDictionary;
    }

    public void setColumnBinaryDictionary(RealmDictionary<byte[]> columnBinaryDictionary) {
        this.columnBinaryDictionary = columnBinaryDictionary;
    }

    public RealmDictionary<Date> getColumnDateDictionary() {
        return columnDateDictionary;
    }

    public void setColumnDateDictionary(RealmDictionary<Date> columnDateDictionary) {
        this.columnDateDictionary = columnDateDictionary;
    }

    public RealmDictionary<ObjectId> getColumnObjectIdDictionary() {
        return columnObjectIdDictionary;
    }

    public void setColumnObjectIdDictionary(RealmDictionary<ObjectId> columnObjectIdDictionary) {
        this.columnObjectIdDictionary = columnObjectIdDictionary;
    }

    public RealmDictionary<UUID> getColumnUUIDDictionary() {
        return columnUUIDDictionary;
    }

    public void setColumnUUIDDictionary(RealmDictionary<UUID> columnUUIDDictionary) {
        this.columnUUIDDictionary = columnUUIDDictionary;
    }

    public RealmDictionary<Decimal128> getColumnDecimal128Dictionary() {
        return columnDecimal128Dictionary;
    }

    public void setColumnDecimal128Dictionary(RealmDictionary<Decimal128> columnDecimal128Dictionary) {
        this.columnDecimal128Dictionary = columnDecimal128Dictionary;
    }

    public RealmDictionary<RealmAny> getColumnRealmAnyDictionary() {
        return columnRealmAnyDictionary;
    }

    public void setColumnRealmAnyDictionary(RealmDictionary<RealmAny> columnRealmAnyDictionary) {
        this.columnRealmAnyDictionary = columnRealmAnyDictionary;
    }
}


text:
package org.http4s.internal.parboiled2

class CustomCharAndStringExpansionSpec extends TestParserSpec {

  "The parser" should {

    "allow for custom char expansion" in new TestParser0 {
      implicit def chWithX(c: Char): Rule0 =
        if (c == EOI) rule(ch(EOI)) else rule { ch(c) ~ ch('x') }

      def targetRule = rule { 'a' ~ 'b' ~ EOI }

      "axbx" must beMatched
      "ab" must beMismatched
    }

    "allow for custom string expansion" in new TestParser0 {
      implicit def wspStr(s: String): Rule0 = rule {
        str(s) ~ zeroOrMore(' ')
      }

      def targetRule = rule { "foo" ~ "bar" ~ EOI }

      "foobar" must beMatched
      "foo   bar" must beMatched
      "foo" must beMismatched
    }
  }
}


text:
<!doctype html>

    <meta charset="utf-8" />
    <meta content="IE=edge;chrome=1" http-equiv="X-UA-Compatible" />
    <title>dognews</title>
    <meta content="width=device-width, initial-scale=1" name="viewport" />
    <link rel="alternate" type="application/atom+xml" title="Atom Feed" href="/feed.xml" /><link href="../../../css/all.css" media="screen" rel="stylesheet" type="text/css" />
    <link href="/favicon.png" rel="icon" type="image/png" />

          <button class="navbar-toggle collapsed" data-target=".navbar-ex1-collapse" data-toggle="collapse" type="button">Toggle navigation</button>dognews

               Über Uns

               Newsletter!

              Categories

                  businessidee (38)

                  deutschland (596)

                  erziehung (35)

                  fotografie (5)

                  freizeit (83)

                  gesetz (38)

                  gesundheit (116)

                  herdenhunde (10)

                  hundesachkunde (13)

                  hundesport (12)

                  kinder (9)

                  kurioses (29)

                  oesterreich (63)

                  rassen (8)

                  ratgeber (161)

                  rettungshunde (3)

                  schweiz (99)

                  senioren (10)

                  stars (11)

                  urlaub (39)

                  veranstaltung (1)

                  wandern (17)

                  wissen (200)

              By Year

                  2017 (8)

                  2016 (55)

                  2015 (458)

                  2014 (273)

            Articles tagged 'schweiz'

            Page 3 of 9

            Previous page

              Tierschützerin Susy Utzingers Appell an alle Tierfreunde: «Nehmt keine Hunde aus den Ferien ...

              ratgeber
              schweiz
              gesetz

               Posted on Aug 18

      Als Lennox an der Schweizer Grenze entdeckt wurde, schien sein Schicksal besiegelt: Der vier Monate alte Boxer hat einen coupierten Schwanz. Das aber ist laut Schweizer Tierschutzgesetz nicht erlaubt. Also muss der Welpe innert einer...

Read More

              Zürichsee: Surfbrett-Kurse für Hunde liegen im Trend

              freizeit
              schweiz

               Posted on Aug 14

      Zürichsee Surfbrett-Kurse für Hunde liegen im Trend Hunde erobern die Gewässer im Kanton Zürich: Eine Organisation bietet für sie und ihre Besitzer neu Kurse im Stand Up Paddling an.
                Link

Read More

              St.Gallen ohne Rassenliste

              schweiz
              gesetz

               Posted on Aug  5

      Im Kanton St.Gallen soll eine Person künftig höchstens noch drei Hunde gleichzeitig ausführen dürfen.
                Link

Read More

              news.ch - Schweizer verwöhnen ihre Heimtiere - aber versichern sie nicht

              wissen
              schweiz

               Posted on Jul 31

      Obwohl Schweizerinnen und Schweizer sich gerne rundum absichern - nicht selten doppelt - hat nicht einmal jeder zehnte Tierhalter für seinen Hund oder seine Katze eine Versicherung abgeschlossen, wie der Internet-Vergleichsdienst comparis...

Read More

              Wenig Regeln für Hunde im Kanton Zug

              schweiz
              gesetz

               Posted on Jul  7

      Der Zuger Kantonsrat setzt auf Eigenverantwortung. Eine generelle Leinenpflicht, wie sie etwa der Nachbarkanton Schwyz kennt, soll es im Kanton Zug nicht geben. An die Leine sollen die Vierbeiner nur in Naturschutzgebieten, auf Friedh...

Read More

              Nicht nur die Chinesen spinnen: Auch in der Schweiz wird Hund gegessen

              wissen
              schweiz

               Posted on Jul  3

      Frau Utzinger, wieso empört es uns dermassen, wenn Menschen Hundefleisch essen?
                Link

Read More

              Gemeinsames Spiel stärkt die Bindung

              wissen
              schweiz

               Posted on Jun 19

      John Bradshaw und seine Kolleginnen von der Universität Bristol gehen in ihrem neuesten Artikel der Frage nach, warum erwachsene Hunde spielen. Dabei fassen sie die aktuelle Literatur zum hündischen Spielverhalten zusammen. Während Spielverhalten...

Read More

              Hundebesitzer treiben ihre Liebsten zur totalen Erschöpfung: Jetzt hat auch Bello Burn-out

              gesundheit
              schweiz

               Posted on Jun 18

      Als Silver (2) im August vor zwei Jahren aus England in die Schweiz kam, war er ein lebhafter Welpe. Der Border Collie bewegte sich ständig, frass viel und gerne. Vier Monate später war alles anders. «Nach einem fünfminütigen Spaziergang...

Read More

              Rettung für verängstigte Hündeler: Smartphone-App warnt vor Giftköder

              ratgeber
              schweiz

               Posted on Jun 16

      Die beiden Tftler Amalia und Sascha Schoppengerd aus Reutte () liess das Thema keine Ruhe - kein Wunder: Ihre beiden Siberian Huskys Aurora und Maya sind ein fester Bestandteil ihrer Familie. So entwickelten die beiden leidenschaftlichen...

Read More

              Tierischer Rekrut aus dem Thurgau

              wissen
              schweiz

               Posted on Jun  3

      Die Schweizer Armee sucht Hunde aus Schweizer Zuchten, um diese zu Diensthunden auszubilden. Einer der ersten Armeehunde aus einer Schweizer Zucht könnte aus dem Thurgau kommen. Foxx, ein junger Deutscher Schäferhund aus Freidorf, könnte...

Read More

              Haben Hunde ein schlechtes Gewissen?

              wissen
              schweiz

               Posted on Jun  2

      Milou mit schlechtem Gewissen? Diese Situation kennen sicherlich viele: Man kommt nach Hause und stellt nach Betreten der Wohnung fest, dass Bello verbotenerweise auf dem Bett gelegen hat, der Inhalt des Mülleimers im Wohnzimmer verteilt...

Read More

              Urlaub mit Hund

              urlaub
              schweiz

               Posted on May 29

      Einer der ersten Lecky Trails der Schweiz - und der erste im Kanton Graubünden - führt von der Madrisa-Bergstation über das Jägglisch Horn bis nach St. Antönien (Prospekt). Der hundefreundliche Weg führt entlang dem Prättigauer Höhenweg...

Read More

            Next page

              Recent Articles

                Nun ist es raus: Hunde sind klüger als Katzen Dec  5

                Die Macht der Gerüche Jul 27

                Vorsicht giftig! Diese Lebensmittel sollten Hunde nicht fressen Jun 21

                Studie: Schäferhunde können Brustkrebs diagnostizieren Mar 27

                Atopische Dermatitis: Was tun, wenn es juckt und kratzt? / Allergien belasten das Wohlbefinden ... Mar 27

                Tiermedizin - Epilepsie-Gen entdeckt Feb 27

                Auch Haustiere frieren | So kommt Bello durch den Winter Jan 17

                Hunde sind bei Minusgraden schnell unterkühlt Jan 17

                Venedig: Wo die Gondeln Hunde tragen Dec  8

                Hunde heulten halbe Stunde vor Erdbeben Nov  1

              ©2018 dognews - Disclaimer
Powered by Cloudburo Curation Engine

              Categories

                businessidee (38)

                deutschland (596)

                erziehung (35)

                fotografie (5)

                freizeit (83)

                gesetz (38)

                gesundheit (116)

                herdenhunde (10)

                hundesachkunde (13)

                hundesport (12)

                kinder (9)

                kurioses (29)

                oesterreich (63)

                rassen (8)

                ratgeber (161)

                rettungshunde (3)

                schweiz (99)

                senioren (10)

                stars (11)

                urlaub (39)

                veranstaltung (1)

                wandern (17)

                wissen (200)

              By year

                2017 (8)

                2016 (55)

                2015 (458)

                2014 (273)


text:
<?php

function blackswan_autoloader($class_name){
	if (isset($GLOBALS['autoloader'][$class_name])){
		$GLOBALS['debugStack']['Files'][] = './' . $GLOBALS['autoloader'][$class_name];
		require_once(ROOT_DIR . '/' . $GLOBALS['autoloader'][$class_name]);
	}

	// Handle PHP-DebugBar loading
	if (substr($class_name, 0, 8) === 'DebugBar') {
        $filename = str_replace('\\', DIRECTORY_SEPARATOR, trim($class_name, '\\')) . '.php';
        require_once(ROOT_DIR . '/lib/' . $filename);
    }
}


text:
#ifndef DELAUNAY_DISCRETIZATION_WEIGHTEDDISCRETIZER_HH
#define DELAUNAY_DISCRETIZATION_WEIGHTEDDISCRETIZER_HH

#include <functional>

#include "Discretization/Export.hh"

#include "Shape/Point.hh"
#include "Shape/Polygon.hh"
#include "Mesh/Mesh.hh"
#include "Mesh/Mesher.hh"

namespace Delaunay
{
namespace Discretization
{

typedef std::function<double(const Shape::Point&)> WeightFunction;

// WIP
class DELAUNAYDISCRETIZATION_EXPORT WeightedDiscretizer : public Mesh::Mesher
{
public:
  WeightedDiscretizer();
  WeightedDiscretizer(const WeightFunction&);

  void SetWeightFunction(const WeightFunction& w) { this->W = w; }

  void Mesh(const Delaunay::Shape::Polygon&, Delaunay::Mesh::Mesh&);

protected:
  WeightFunction W;
};

}
}

#endif


text:
package tasty.mushrooms.commons.util;

/**
 * 验证工具类
 *
 * @since 1.0.0
 */
public abstract class Assert {

	/**
	 * 验证当前状态是否正确,若表达式为假则抛出IllegalStateException异常
	 *
	 * @param expression 待验证布尔表达式
	 */
	public static void state(boolean expression) {
		state(expression, "[Assertion failed] - this state invariant must be true");
	}

	/**
	 * 验证当前状态是否正确,若表达式为假则抛出IllegalStateException异常
	 *
	 * @param expression 待验证布尔表达式
	 * @param message 抛出异常时所包含的信息
	 */
	public static void state(boolean expression, String message) {
		if (!expression) {
			throw new IllegalStateException(message);
		}
	}

	/**
	 * 验证是否为真,若不为true则抛出IllegalArgumentException异常
	 *
	 * @param expression 待验证布尔表达式
	 * @param message 抛出异常时所包含的信息
	 */
	public static void isTrue(boolean expression, String message) {
		if (!expression) {
			throw new IllegalArgumentException(message);
		}
	}

	/**
	 * 验证对象是否为null,若不为null则抛出IllegalArgumentException异常
	 *
	 * @param object 待验证对象
	 * @param message 抛出异常时所包含的信息
	 */
	public static void isNull(Object object, String message) {
		if (object != null) {
			throw new IllegalArgumentException(message);
		}
	}

	/**
	 * 验证对象是否不为null,若为null则抛出IllegalArgumentException异常
	 *
	 * @param object 待验证对象
	 * @param message 抛出异常时所包含的信息
	 */
	public static void notNull(Object object, String message) {
		if (object == null) {
			throw new IllegalArgumentException(message);
		}
	}

	/**
	 * 验证对象是否为指定类型的实例,若不是则抛出IllegalArgumentException异常
	 *
	 * @param type 用来验证的类型
	 * @param obj 待验证对象
	 * @param message 抛出异常时所包含的信息
	 */
	public static void isInstanceOf(Class<?> type, Object obj, String message) {
		notNull(type, "Type to check against must not be null");
		if (!type.isInstance(obj)) {
			throw new IllegalArgumentException((message.length() > 0 ? message + " " : "") + "Object of class ["
					+ (obj != null ? obj.getClass().getName() : "null") + "] must be an instance of " + type);
		}
	}

	/**
	 * 验证类型是否为指定类型的子类,若不是则抛出IllegalArgumentException异常
	 *
	 * @param superType 用来验证的类型
	 * @param subType 待验证的类型
	 * @param message 抛出异常时所包含的信息
	 */
	public static void isAssignable(Class<?> superType, Class<?> subType, String message) {
		notNull(superType, "Type to check against must not be null");
		if (subType == null || !superType.isAssignableFrom(subType)) {
			throw new IllegalArgumentException(
					(message.length() > 0 ? message + " " : "") + subType + " is not assignable to " + superType);
		}
	}

	/**
	 * 验证字符串是否长度大于0,若不大于0 则抛出IllegalArgumentException异常
	 *
	 * @param text 待验证字符串
	 * @param message 抛出异常时所包含的信息
	 */
	public static void hasLength(String text, String message) {
		if (text.length() == 0) {
			throw new IllegalArgumentException(message);
		}
	}

}


text:
  Lancieux est
      une commune localisée dans le département de Côtes-d'Armor en Bretagne. Elle totalisait 1 330 habitants en 2008.

Le nombre de logements, à Lancieux, était réparti en 2011 en 200 appartements et 1 727 maisons soit
 un marché relativement équilibré.

La ville offre de nombreux  aménagements, elle dispose, entre autres, de un terrain de tennis, un parcours de golf, un terrain de sport et une boucle de randonnée.

À proximité de Lancieux sont positionnées géographiquement les communes de
Saint-Briac-sur-Mer à 2 km, 1 948 habitants,
Ploubalay localisée à 3 km, 2 488 habitants,
Saint-Cast-le-Guildo située à 7 km, 3 394 habitants,
Dinard localisée à 7 km, 10 644 habitants,
Pleurtuit située à 7 km, 5 346 habitants,
Saint-Jacut-de-la-Mer localisée à 2 km, 831 habitants,
 entre autres. De plus, Lancieux est située à seulement dix km de Saint-Malo.

À Lancieux, le prix moyen à l'achat d'un appartement s'évalue à 2 837 € du m² en vente. La valeur moyenne d'une maison à l'achat se situe à 3 108 € du m². À la location la valorisation moyenne se situe à 13,33 € du m² mensuel.


text:
package brut.androlib.res.data.value;

/**
 * @author Ryszard Wiśniewski <brut.alll@gmail.com>
 */
public class ResValue {

}


text:
function g = compute_gratio(D)

% Ikeda M, Oka Y. Brain Behav, 2012. "The relationship between nerve conduction velocity and fiber morphology during peripheral nerve regeneration."
g = 0.220 .* log10(2*D) + 0.508;
% g = 0.76; % if you want a constant g-ratio

% figure
% plot(2.*R, g)

end


text:
package org.cagrid.gaards.authentication.service;

import java.util.HashSet;
import java.util.Set;

import javax.xml.namespace.QName;

public abstract class BaseSubjectProvider implements SubjectProvider{

	private Set<QName> profiles;

	public BaseSubjectProvider(){
		profiles = new HashSet<QName>();
	}

	public void addSupportedProfile(QName profile){
		profiles.add(profile);
	}

	public Set<QName> getSupportedAuthenticationProfiles() {
		return profiles;
	}

}


text:
module Azure::DataFactory::Mgmt::V2017_09_01_preview
  module Models
    #
    # Salesforce Marketing Cloud linked service.
    #
    class SalesforceMarketingCloudLinkedService < LinkedService

      include MsRestAzure

      def initialize
        @type = "SalesforceMarketingCloud"
      end

      attr_accessor :type

      # @return The client ID associated with the Salesforce Marketing Cloud
      # application. Type: string (or Expression with resultType string).
      attr_accessor :client_id

      # @return [SecretBase] The client secret associated with the Salesforce
      # Marketing Cloud application. Type: string (or Expression with
      # resultType string).
      attr_accessor :client_secret

      # @return Specifies whether the data source endpoints are encrypted using
      # HTTPS. The default value is true. Type: boolean (or Expression with
      # resultType boolean).
      attr_accessor :use_encrypted_endpoints

      # @return Specifies whether to require the host name in the server's
      # certificate to match the host name of the server when connecting over
      # SSL. The default value is true. Type: boolean (or Expression with
      # resultType boolean).
      attr_accessor :use_host_verification

      # @return Specifies whether to verify the identity of the server when
      # connecting over SSL. The default value is true. Type: boolean (or
      # Expression with resultType boolean).
      attr_accessor :use_peer_verification

      # @return The encrypted credential used for authentication. Credentials
      # are encrypted using the integration runtime credential manager. Type:
      # string (or Expression with resultType string).
      attr_accessor :encrypted_credential

      #
      # Mapper for SalesforceMarketingCloudLinkedService class as Ruby Hash.
      # This will be used for serialization/deserialization.
      #
      def self.mapper()
        {
          client_side_validation: true,
          required: false,
          serialized_name: 'SalesforceMarketingCloud',
          type: {
            name: 'Composite',
            class_name: 'SalesforceMarketingCloudLinkedService',
            model_properties: {
              additional_properties: {
                client_side_validation: true,
                required: false,
                type: {
                  name: 'Dictionary',
                  value: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'ObjectElementType',
                      type: {
                        name: 'Object'
                      }
                  }
                }
              },
              connect_via: {
                client_side_validation: true,
                required: false,
                serialized_name: 'connectVia',
                type: {
                  name: 'Composite',
                  class_name: 'IntegrationRuntimeReference'
                }
              },
              description: {
                client_side_validation: true,
                required: false,
                serialized_name: 'description',
                type: {
                  name: 'String'
                }
              },
              parameters: {
                client_side_validation: true,
                required: false,
                serialized_name: 'parameters',
                type: {
                  name: 'Dictionary',
                  value: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'ParameterSpecificationElementType',
                      type: {
                        name: 'Composite',
                        class_name: 'ParameterSpecification'
                      }
                  }
                }
              },
              annotations: {
                client_side_validation: true,
                required: false,
                serialized_name: 'annotations',
                type: {
                  name: 'Sequence',
                  element: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'ObjectElementType',
                      type: {
                        name: 'Object'
                      }
                  }
                }
              },
              type: {
                client_side_validation: true,
                required: true,
                serialized_name: 'type',
                type: {
                  name: 'String'
                }
              },
              client_id: {
                client_side_validation: true,
                required: true,
                serialized_name: 'typeProperties.clientId',
                type: {
                  name: 'Object'
                }
              },
              client_secret: {
                client_side_validation: true,
                required: false,
                serialized_name: 'typeProperties.clientSecret',
                type: {
                  name: 'Composite',
                  polymorphic_discriminator: 'type',
                  uber_parent: 'SecretBase',
                  class_name: 'SecretBase'
                }
              },
              use_encrypted_endpoints: {
                client_side_validation: true,
                required: false,
                serialized_name: 'typeProperties.useEncryptedEndpoints',
                type: {
                  name: 'Object'
                }
              },
              use_host_verification: {
                client_side_validation: true,
                required: false,
                serialized_name: 'typeProperties.useHostVerification',
                type: {
                  name: 'Object'
                }
              },
              use_peer_verification: {
                client_side_validation: true,
                required: false,
                serialized_name: 'typeProperties.usePeerVerification',
                type: {
                  name: 'Object'
                }
              },
              encrypted_credential: {
                client_side_validation: true,
                required: false,
                serialized_name: 'typeProperties.encryptedCredential',
                type: {
                  name: 'Object'
                }
              }
            }
          }
        }
      end
    end
  end
end


text:
/**
 * Configurable user inactivity timer and logout redirect. Works across
 * multiple windows and tabs from the same domain. Depends on bootsrap bootbar
 * for displaying a warning alert.
 *
 * Based upon Jquery-idleTimeout by JillElaine, which is available at
 * http://jillelaine.github.io/jquery-idleTimeout/.
 **/

(function ($) {

	$.fn.idleTimeout = function (options) {

		//##############################
		//## Configuration Variables
		//##############################
		var defaults = {
			idleTimeLimit: 1200, // 'No activity' before auto logout time limit in seconds. 1200 = 20 Minutes
			redirectUrl: '/logout', // redirect to this url on timeout logout. Set to "redirectUrl: false" to disable redirect

			// optional custom callback to perform before logout
			customCallback: false, // set to false for no customCallback
			// customCallback:    function () {    // define optional custom js function
			// perform custom action before logout
			// },

			// configure which activity events to detect
			// http://www.quirksmode.org/dom/events/
			// https://developer.mozilla.org/en-US/docs/Web/Reference/Events
			activityEvents: 'click keypress scroll wheel mousewheel mousemove', // separate each event with a space

			// Warning alert configuration
			enableAlert: true, // Set to false for logout without warning alert
			alertDisplayLimit: 180, // Time to display the warning alert before logout (and optional callback) in seconds. 180 = 3 Minutes
			alertTitle: 'Session Expiration Warning',
			// The alert display message. Must have a span with id countdownDisplay, into which the time remaining will be inserted.
			alertMessage: "You will be logged off in  due to inactivity. Click anywhere to continue using Eureka!",
			// server-side session keep-alive timer
			sessionKeepAliveTimer: 600 // Ping the server at this interval in seconds. 600 = 10 Minutes
			// sessionKeepAliveTimer: false // Set to false to disable pings

		},
		//##############################
		//## Private Variables
		//##############################
		opts = $.extend(defaults, options),
				checkHeartbeat = 2, // frequency to check for timeouts in seconds
				localObjectStorage,
				idleTimer,
				logoutManager,
				warningAlert,

		//##############################
		//## Private Functions
		//##############################

		// Appropriately translates to/from strings for localStorage.
		localObjectStorage = {
			setItem: function (key, value) {
				localStorage.setItem(key, JSON.stringify(value));
			},

			getItem: function (key) {
				return JSON.parse(localStorage.getItem(key));
			}
		},

		idleTimer = (function() {
			var idleTimerIval = null;

			checkTimeout = function () {
				var timeNow = $.now(),
						timeIdleTimeout = activity.getLast() + (opts.idleTimeLimit * 1000),
						timeToShowAlert = timeIdleTimeout - (opts.alertDisplayLimit * 1000),
						warningAlertOpen = warningAlert.isOpen();

				if (timeNow > timeIdleTimeout || logoutManager.isLoggedOut()) {
					logoutManager.logoutUser();
				} else {
					if (opts.enableAlert) {
						if (timeNow > timeToShowAlert) {
							if (!warningAlertOpen) {
								warningAlert.open();
							}
						} else {
							if (warningAlertOpen) {
								warningAlert.close();
							}
						}
					}
				}
			};

			return {
				init: function() {
					logoutManager.init();
					idleTimerIval = setInterval(checkTimeout, checkHeartbeat * 1000);
					activity.init();
				}
			};
		})(),

		activity = (function() {
			var recentActivity = null,
					recentActivityIval = null,
					keepSessionIval = null,
					sessionKeepAliveUrl = window.location.href,// set URL to ping to user's current window
					idleTimerLastActivity = null;

			var setLast = function(lastActivity) {
				idleTimerLastActivity = lastActivity;
				localObjectStorage.setItem('idleTimerLastActivity', lastActivity);
			},

			getLast = function() {
				return localObjectStorage.getItem('idleTimerLastActivity');
			},

			keepSessionAlive = function() {
				// A heuristic to avoid multiple windows invoking the keep alive URL.
				if (idleTimerLastActivity === getLast()) {
					$.get(sessionKeepAliveUrl);
				}
			},

			createKeepSessionIval = function() {
				keepSessionIval = setInterval(keepSessionAlive, (opts.sessionKeepAliveTimer * 1000));
			},

			check = function() {
				if (recentActivity) {
					setLast(recentActivity);
					recentActivity = null;
				}
			};

			return {
				init: function() {
					$('body').on(opts.activityEvents, function () {
						recentActivity = $.now();
					});
					setLast($.now());
					recentActivityIval = setInterval(check, 1000);
					if (opts.sessionKeepAliveTimer) {
						createKeepSessionIval();
					}
				},

				restart: function() {
					clearInterval(keepSessionIval);
					keepSessionAlive();
					createKeepSessionIval();
				},

				getLast: getLast
			};
		})(),

		warningAlert = (function() {
			var warningAlertHtml = null,
					remainingTimer = null,
					origTitle = document.title; // save original browser title

			startCountdownDisplay = function () { // display remaining time on warning dialog
				var countdownDisplay = $('#countdownDisplay');

				if (countdownDisplay) {
					var timeDialogTimeout = activity.getLast() + (opts.idleTimeLimit * 1000);

					var updateCountdown = function () {
						var dialogDisplaySeconds = Math.max((timeDialogTimeout - $.now()) / 1000, 0);
						var mins = Math.floor(dialogDisplaySeconds / 60); // minutes
						if (mins < 10) {
							mins = '0' + mins;
						}
						var secs = Math.floor(dialogDisplaySeconds - (mins * 60)); // seconds
						if (secs < 10) {
							secs = '0' + secs;
						}
						countdownDisplay.html(mins + ':' + secs);
					};

					updateCountdown();
					remainingTimer = setInterval(updateCountdown, 1000);
				}
			};

			return {
				open: function () {
					warningAlertHtml = $.bootbar.warning(opts.alertMessage, {
						autoDismiss: false,
						onDismiss: function () {
							clearInterval(remainingTimer);
						}
					});
					startCountdownDisplay();
					document.title = opts.alertTitle;
				},

				isOpen: function() {
					if (warningAlertHtml) {
						return true;
					} else {
						return false;
					}
				},

				close: function () {
					warningAlertHtml.close();
					warningAlertHtml = null;
					document.title = origTitle;
				}
			};
		})(),

		logoutManager = {
			init: function () {
				localObjectStorage.setItem('idleTimerLoggedOut', false);

				//If exists, hook the logout button or link into idletimeout.
				$(".idletimeout-logout").click(function () {
					localObjectStorage.setItem('idleTimerLoggedOut', true);
				});
			},

			isLoggedOut: function() {
				return localObjectStorage.getItem('idleTimerLoggedOut');
			},

			logoutUser: function () {
				localObjectStorage.setItem('idleTimerLoggedOut', true);

				if (opts.customCallback) {
					opts.customCallback();
				}

				if (opts.redirectUrl) {
					window.location.href = opts.redirectUrl;
				}
			}
		};

		//###############################
		// Build & Return the instance of the item as a plugin
		//###############################
		return this.each(function () {
			idleTimer.init();
		});
	};
}(jQuery));


text:
set(CMAKE_SYSTEM_NAME Linux)

include(CMakeForceCompiler)

if(with_MPI)
  CMAKE_FORCE_C_COMPILER(mpifccpx GNU)
  CMAKE_FORCE_CXX_COMPILER(mpiFCCpx GNU)
  CMAKE_FORCE_Fortran_COMPILER(mpifrtpx GNU)
else()
  CMAKE_FORCE_C_COMPILER(fccpx GNU)
  CMAKE_FORCE_CXX_COMPILER(FCCpx GNU)
  CMAKE_FORCE_Fortran_COMPILER(frtpx GNU)
endif()

set(CMAKE_FIND_ROOT_PATH /opt/FJSVfxlang/1.2.1)   # RIIT fx10, hayaka
set(CMAKE_INCLUDE_PATH /opt/FJSVfxlang/1.2.1/include)
set(CMAKE_LIBRARY_PATH /opt/FJSVfxlang/1.2.1/lib64)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

set(TARGET_ARCH "FX10")
set(USE_F_TCS "YES")


text:
/*********************************************************************/
/* Copyright 2009, 2010 The University of Texas at Austin.           */
/* All rights reserved.                                              */
/*                                                                   */
/* Redistribution and use in source and binary forms, with or        */
/* without modification, are permitted provided that the following   */
/* conditions are met:                                               */
/*                                                                   */
/*   1. Redistributions of source code must retain the above         */
/*      copyright notice, this list of conditions and the following  */
/*      disclaimer.                                                  */
/*                                                                   */
/*   2. Redistributions in binary form must reproduce the above      */
/*      copyright notice, this list of conditions and the following  */
/*      disclaimer in the documentation and/or other materials       */
/*      provided with the distribution.                              */
/*                                                                   */
/*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
/*    AUSTIN  ``AS IS''  AND ANY  EXPRESS OR  IMPLIED WARRANTIES,    */
/*    INCLUDING, BUT  NOT LIMITED  TO, THE IMPLIED  WARRANTIES OF    */
/*    MERCHANTABILITY  AND FITNESS FOR  A PARTICULAR  PURPOSE ARE    */
/*    DISCLAIMED.  IN  NO EVENT SHALL THE UNIVERSITY  OF TEXAS AT    */
/*    AUSTIN OR CONTRIBUTORS BE  LIABLE FOR ANY DIRECT, INDIRECT,    */
/*    INCIDENTAL,  SPECIAL, EXEMPLARY,  OR  CONSEQUENTIAL DAMAGES    */
/*    (INCLUDING, BUT  NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE    */
/*    GOODS  OR  SERVICES; LOSS  OF  USE,  DATA,  OR PROFITS;  OR    */
/*    BUSINESS INTERRUPTION) HOWEVER CAUSED  AND ON ANY THEORY OF    */
/*    LIABILITY, WHETHER  IN CONTRACT, STRICT  LIABILITY, OR TORT    */
/*    (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY WAY OUT    */
/*    OF  THE  USE OF  THIS  SOFTWARE,  EVEN  IF ADVISED  OF  THE    */
/*    POSSIBILITY OF SUCH DAMAGE.                                    */
/*                                                                   */
/* The views and conclusions contained in the software and           */
/* documentation are those of the authors and should not be          */
/* interpreted as representing official policies, either expressed   */
/* or implied, of The University of Texas at Austin.                 */
/*********************************************************************/

#include <stdio.h>
#include "common.h"
#ifdef OS_LINUX
#include <sys/sysinfo.h>
#include <sched.h>
#include <errno.h>
#include <linux/unistd.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/resource.h>
#endif

#ifdef OS_HAIKU
#include <unistd.h>
#endif

#if defined(OS_FREEBSD) || defined(OS_OPENBSD) || defined(OS_NETBSD) || defined(OS_DRAGONFLY) || defined(OS_DARWIN)
#include <sys/sysctl.h>
#include <sys/resource.h>
#endif

#define FIXED_PAGESIZE 4096

void *sa = NULL;
void *sb = NULL;
static double static_buffer[BUFFER_SIZE/sizeof(double)];

void *blas_memory_alloc(int numproc){

  if (sa == NULL){
#if 0
    sa = (void *)qalloc(QFAST, BUFFER_SIZE);
#else
    sa = (void *)malloc(BUFFER_SIZE);
#endif
    sb = (void *)&static_buffer[0];
  }

  return sa;
}

void blas_memory_free(void *free_area){
  return;
}

extern void openblas_warning(int verbose, const char * msg);

#ifndef SMP

#define blas_cpu_number 1
#define blas_num_threads 1

/* Dummy Function */
int  goto_get_num_procs  (void) { return 1;};
void goto_set_num_threads(int num_threads) {};

#else

#if defined(OS_LINUX) || defined(OS_SUNOS)
#ifndef NO_AFFINITY
int get_num_procs(void);
#else
int get_num_procs(void) {

  static int nums = 0;
  cpu_set_t cpuset,*cpusetp;
  size_t size;
  int ret;

#if defined(__GLIBC_PREREQ)
#if !__GLIBC_PREREQ(2, 7)
  int i;
#if !__GLIBC_PREREQ(2, 6)
  int n;
#endif
#endif
#endif

  if (!nums) nums = sysconf(_SC_NPROCESSORS_CONF);
#if !defined(OS_LINUX)
  return nums;
#endif

/*
#if !defined(__GLIBC_PREREQ)
  return nums;
#else
 #if !__GLIBC_PREREQ(2, 3)
  return nums;
 #endif

 #if !__GLIBC_PREREQ(2, 7)
  ret = sched_getaffinity(0,sizeof(cpuset), &cpuset);
  if (ret!=0) return nums;
  n=0;
  #if !__GLIBC_PREREQ(2, 6)
  for (i=0;i<nums;i++)
     if (CPU_ISSET(i,&cpuset)) n++;
  nums=n;
  #else
  nums = CPU_COUNT(sizeof(cpuset),&cpuset);
  #endif
  return nums;
 #else
  if (nums >= CPU_SETSIZE) {
    cpusetp = CPU_ALLOC(nums);
      if (cpusetp == NULL) {
        return nums;
      }
    size = CPU_ALLOC_SIZE(nums);
    ret = sched_getaffinity(0,size,cpusetp);
    if (ret!=0) {
      CPU_FREE(cpusetp);
      return nums;
    }
    ret = CPU_COUNT_S(size,cpusetp);
    if (ret > 0 && ret < nums) nums = ret;
    CPU_FREE(cpusetp);
    return nums;
  } else {
    ret = sched_getaffinity(0,sizeof(cpuset),&cpuset);
    if (ret!=0) {
      return nums;
    }
    ret = CPU_COUNT(&cpuset);
    if (ret > 0 && ret < nums) nums = ret;
    return nums;
  }
 #endif
#endif
*/
   return 1;
}
#endif
#endif

#ifdef OS_ANDROID
int get_num_procs(void) {
  static int nums = 0;
  if (!nums) nums = sysconf(_SC_NPROCESSORS_CONF);
  return nums;
}
#endif

#ifdef OS_HAIKU
int get_num_procs(void) {
  static int nums = 0;
  if (!nums) nums = sysconf(_SC_NPROCESSORS_CONF);
  return nums;
}
#endif

#ifdef OS_AIX
int get_num_procs(void) {
  static int nums = 0;
  if (!nums) nums = sysconf(_SC_NPROCESSORS_CONF);
  return nums;
}
#endif

#ifdef OS_WINDOWS

int get_num_procs(void) {

  static int nums = 0;

  if (nums == 0) {

    SYSTEM_INFO sysinfo;

    GetSystemInfo(&sysinfo);

    nums = sysinfo.dwNumberOfProcessors;
  }

  return nums;
}

#endif

#if defined(OS_FREEBSD) || defined(OS_OPENBSD) || defined(OS_NETBSD) || defined(OS_DRAGONFLY)

int get_num_procs(void) {

  static int nums = 0;

  int m[2];
  size_t len;

  if (nums == 0) {
    m[0] = CTL_HW;
    m[1] = HW_NCPU;
    len = sizeof(int);
    sysctl(m, 2, &nums, &len, NULL, 0);
  }

  return nums;
}

#endif

#if defined(OS_DARWIN)
int get_num_procs(void) {
  static int nums = 0;
  size_t len;
  if (nums == 0){
    len = sizeof(int);
    sysctlbyname("hw.physicalcpu", &nums, &len, NULL, 0);
  }
  return nums;
}
/*
void set_stack_limit(int limitMB){
  int result=0;
  struct rlimit rl;
  rlim_t StackSize;

  StackSize=limitMB*1024*1024;
  result=getrlimit(RLIMIT_STACK, &rl);
  if(result==0){
    if(rl.rlim_cur < StackSize){
      rl.rlim_cur=StackSize;
      result=setrlimit(RLIMIT_STACK, &rl);
      if(result !=0){
        fprintf(stderr, "OpenBLAS: set stack limit error =%d\n", result);
      }
    }
  }
}
*/
#endif

/*
OpenBLAS uses the numbers of CPU cores in multithreading.
It can be set by openblas_set_num_threads(int num_threads);
*/
int blas_cpu_number  = 0;
/*
The numbers of threads in the thread pool.
This value is equal or large than blas_cpu_number. This means some threads are sleep.
*/
int blas_num_threads = 0;

int  goto_get_num_procs  (void) {
  return blas_cpu_number;
}

void openblas_fork_handler()
{
  // This handler shuts down the OpenBLAS-managed PTHREAD pool when OpenBLAS is
  // built with "make USE_OPENMP=0".
  // Hanging can still happen when OpenBLAS is built against the libgomp
  // implementation of OpenMP. The problem is tracked at:
  //   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=60035
  // In the mean time build with USE_OPENMP=0 or link against another
  // implementation of OpenMP.
#if !((defined(OS_WINDOWS) && !defined(OS_CYGWIN_NT)) || defined(OS_ANDROID)) && defined(SMP_SERVER)
  int err;
  err = pthread_atfork ((void (*)(void)) BLASFUNC(blas_thread_shutdown), NULL, NULL);
  if(err != 0)
    openblas_warning(0, "OpenBLAS Warning ... cannot install fork handler. You may meet hang after fork.\n");
#endif
}

extern int openblas_num_threads_env();
extern int openblas_goto_num_threads_env();
extern int openblas_omp_num_threads_env();

int blas_get_cpu_number(void){
#if defined(OS_LINUX) || defined(OS_WINDOWS) || defined(OS_FREEBSD) || defined(OS_OPENBSD) || defined(OS_NETBSD) || defined(OS_DRAGONFLY) || defined(OS_DARWIN) || defined(OS_ANDROID)
  int max_num;
#endif
  int blas_goto_num   = 0;
  int blas_omp_num    = 0;

  if (blas_num_threads) return blas_num_threads;

#if defined(OS_LINUX) || defined(OS_WINDOWS) || defined(OS_FREEBSD) || defined(OS_OPENBSD) || defined(OS_NETBSD) || defined(OS_DRAGONFLY) || defined(OS_DARWIN) || defined(OS_ANDROID)
  max_num = get_num_procs();
#endif

  // blas_goto_num = 0;
#ifndef USE_OPENMP
  blas_goto_num=openblas_num_threads_env();
  if (blas_goto_num < 0) blas_goto_num = 0;

  if (blas_goto_num == 0) {
    blas_goto_num=openblas_goto_num_threads_env();
    if (blas_goto_num < 0) blas_goto_num = 0;
  }

#endif

  // blas_omp_num = 0;
  blas_omp_num=openblas_omp_num_threads_env();
  if (blas_omp_num < 0) blas_omp_num = 0;

  if (blas_goto_num > 0) blas_num_threads = blas_goto_num;
  else if (blas_omp_num > 0) blas_num_threads = blas_omp_num;
  else blas_num_threads = MAX_CPU_NUMBER;

#if defined(OS_LINUX) || defined(OS_WINDOWS) || defined(OS_FREEBSD) || defined(OS_OPENBSD) || defined(OS_NETBSD) || defined(OS_DRAGONFLY) || defined(OS_DARWIN) || defined(OS_ANDROID)
  if (blas_num_threads > max_num) blas_num_threads = max_num;
#endif

  if (blas_num_threads > MAX_CPU_NUMBER) blas_num_threads = MAX_CPU_NUMBER;

#ifdef DEBUG
  printf( "Adjusted number of threads : %3d\n", blas_num_threads);
#endif

  blas_cpu_number = blas_num_threads;

  return blas_num_threads;
}
#endif

int openblas_get_num_procs(void) {
#ifndef SMP
  return 1;
#else
  return get_num_procs();
#endif
}

int openblas_get_num_threads(void) {
#ifndef SMP
  return 1;
#else
  // init blas_cpu_number if needed
  blas_get_cpu_number();
  return blas_cpu_number;
#endif
}


text:
#include "org_jitsi_impl_neomedia_jmfext_media_protocol_directshow_DSFormat.h"

#include <windows.h>
#include <dshow.h>
#include <uuids.h>

#define DEFINE_DSFORMAT_PIXELFORMAT(pixFmt) \
    JNIEXPORT jint JNICALL \
    Java_org_jitsi_impl_neomedia_jmfext_media_protocol_directshow_DSFormat_##pixFmt \
        (JNIEnv *env, jclass clazz) \
    { \
        return MEDIASUBTYPE_##pixFmt.Data1; \
    }

DEFINE_DSFORMAT_PIXELFORMAT(ARGB32)
DEFINE_DSFORMAT_PIXELFORMAT(AYUV)
DEFINE_DSFORMAT_PIXELFORMAT(I420)
DEFINE_DSFORMAT_PIXELFORMAT(IF09)
DEFINE_DSFORMAT_PIXELFORMAT(IMC1)
DEFINE_DSFORMAT_PIXELFORMAT(IMC2)
DEFINE_DSFORMAT_PIXELFORMAT(IMC3)
DEFINE_DSFORMAT_PIXELFORMAT(IMC4)
DEFINE_DSFORMAT_PIXELFORMAT(IYUV)
DEFINE_DSFORMAT_PIXELFORMAT(MJPG)
DEFINE_DSFORMAT_PIXELFORMAT(NV12)
DEFINE_DSFORMAT_PIXELFORMAT(RGB24)
DEFINE_DSFORMAT_PIXELFORMAT(RGB32)
DEFINE_DSFORMAT_PIXELFORMAT(UYVY)
DEFINE_DSFORMAT_PIXELFORMAT(Y211)
DEFINE_DSFORMAT_PIXELFORMAT(Y411)
DEFINE_DSFORMAT_PIXELFORMAT(Y41P)
DEFINE_DSFORMAT_PIXELFORMAT(YUY2)
DEFINE_DSFORMAT_PIXELFORMAT(YV12)
DEFINE_DSFORMAT_PIXELFORMAT(YVU9)
DEFINE_DSFORMAT_PIXELFORMAT(YVYU)