text:
package com.royken.bracongo.survey.dao;

import com.royken.bracongo.survey.entities.Boisson;
import com.royken.bracongo.survey.entities.Format;
import com.royken.bracongo.survey.entities.FormatBoisson;
import com.royken.bracongo.survey.entities.TypeBoisson;
import com.royken.generic.dao.DataAccessException;
import com.royken.generic.dao.IGenericDao;
import java.util.List;

/**
 *
 * @author Kenfack Valmy-Roi <roykenvalmy@gmail.com>
 */
public interface IFormatBoissonDao extends IGenericDao<FormatBoisson, Long>{

    /**
     * Retourne la liste des formats de boisson
     * @return la liste
     * @throws DataAccessException
     */
    public List<FormatBoisson> findAllActive() throws DataAccessException;

    /**
     *
     * @param bracongo
     * @param typeBoisson
     * @return
     * @throws DataAccessException
     */
    public List<FormatBoisson> findAllByTypeForEnterprise(Boolean bracongo, TypeBoisson typeBoisson)throws DataAccessException;

    /**
     * Retourne le format de boisson connaissant la boisson et le format
     * @param boisson la boisson
     * @param format le format
     * @return le format de boisson recherché
     * @throws DataAccessException
     */
    public FormatBoisson findByBoissonAndFormat(Boisson boisson, Format format) throws DataAccessException;

    /**
     * Retourne la liste des formats de boisson d'une boisson
     * @param boisson la boisson
     * @return la liste
     * @throws DataAccessException
     */
    public List<FormatBoisson> findByBoisson(Boisson boisson) throws DataAccessException;

    /**
     * Retourne la liste des formats de boisson d'une entreprise, d'yn type de boisson et d'un format
     * @param bracongo l'entreprise (True si c'est Bracongo)
     * @param typeBoisson le type de boisson (BI pour bière, BG pour boisson gazeuse)
     * @param format le format
     * @return la liste
     * @throws DataAccessException
     */
    public List<FormatBoisson> findAllByTypeForEnterpriseAndFormat(Boolean bracongo, TypeBoisson typeBoisson, Format format) throws DataAccessException;

}


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cucumber</groupId>
    <artifactId>cucumber-java-selenium</artifactId>
    <version>0.0.1</version>
    <packaging>jar</packaging>
    <name>Cucumber-JVM Selenium</name>

    <dependencies>
        <dependency>
            <groupId>info.cukes</groupId>
            <artifactId>cucumber-java</artifactId>
            <version>1.2.2</version>
        </dependency>

        <dependency>
            <groupId>info.cukes</groupId>
            <artifactId>cucumber-junit</artifactId>
            <version>1.2.2</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>info.cukes</groupId>
            <artifactId>cucumber-picocontainer</artifactId>
            <version>1.2.2</version>
        </dependency>

        <dependency>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-all</artifactId>
            <version>1.3</version>
        </dependency>

        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>2.46.0</version>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.11-beta3</version>
        </dependency>
        <dependency>
            <groupId>xml-apis</groupId>
            <artifactId>xml-apis</artifactId>
            <version>2.0.2</version>
        </dependency>

        <dependency>
            <groupId>xerces</groupId>
            <artifactId>xercesImpl</artifactId>
            <version>2.8.0</version>
        </dependency>

        <dependency>
            <groupId>com.esotericsoftware.yamlbeans</groupId>
            <artifactId>yamlbeans</artifactId>
            <version>1.08</version>
        </dependency>

    </dependencies>

</project>

redpajama_set_name: RedPajamaGithub


text:
import morepath

class app(morepath.App):
    pass

class StaticMethod:
    pass

class Root:
    def __init__(self):
        self.value = "ROOT"

    @staticmethod
    @app.path(model=StaticMethod, path="static")
    def static_method():
        return StaticMethod()

@app.view(model=StaticMethod)
def static_method_default(self, request):
    return "Static Method"


text:
module MusicTheory
  VERSION = "0.3.11"
end


text:
namesync |build-status| |python-versions|
==============================================

Sync DNS records stored in a flat file format to your DNS provider. Cloudflare support currently provided.

.. |build-status| image:: https://secure.travis-ci.org/dnerdy/namesync.svg?branch=master
    :alt: Build Status
    :target: http://travis-ci.org/dnerdy/namesync

.. |python-versions| image:: https://img.shields.io/badge/python-2.7_3.4-blue.svg
    :alt: Python Versions

Installation |pypi-version|
---------------------------

::

    $ pip install namesync

.. |pypi-version| image:: https://img.shields.io/pypi/v/namesync.svg
    :alt: PyPI Version
    :target: http://pypi.python.org/pypi/namesync

Quick Guide
-----------

Create a file with the name of your domain::

    $ touch example.com

Or, if you have existing records, you can export them::

    $ namesync --get example.com

Enter one record per line with the following format::

   <record-type> <name> <value> <ttl:optional>

For example::

    A       *       10.10.10.10         # You can even use comments
    A       .       10.10.10.10         # . references the domain itself, example.com
    A       test    10.10.10.11
    A       example 10.10.10.12 86400
    CNAME   mail    ghs.googlehosted.com
    MX      .       aspmx.l.google.com

MX records allow you to specify a priority::

   MX <name> <value> <priority:optional> <ttl:optional>

Like this::

    MX      .       alt1.aspmx.l.google.com 20
    MX      .       aspmx3.googlemail.com 30 86400

If the value contains spaces, quote it::

    TXT     .       "v=spf1 a include:amazonses.com include:_spf.google.com ~all"

Then sync your records::

   $ namesync example.com

You will be given a chance to review your changes before they are synced::

   The following changes will be made:
   ADD    A     *       10.10.10.10
   ADD    A     example 10.10.10.12 86400
   ADD    A     test    10.10.10.11
   ADD    CNAME mail    ghs.googlehosted.com
   ADD    MX    .       aspmx.l.google.com
   UPDATE A     .       10.10.10.10
   REMOVE A     old     10.10.10.13
   Do you want to continue? [y/N]

Usage
-----

::

    usage: namesync [-h] [-g] [-z ZONE] [-y] [-p PROVIDER] [-c CONFIG] RECORDS

    positional arguments:
      RECORDS               file containing DNS records, one per line. The zone is
                            derived from the basename of this file. For example,
                            if "dns/example.com" is used then the zone is assumed
                            to be "example.com" unless the --zone option is used

    optional arguments:
      -h, --help            show this help message and exit
      -g, --get             save existing DNS records to RECORDS
      -z ZONE, --zone ZONE  specify the zone instead of using the RECORDS filename
      -y, --yes             sync records without prompting before making changes
      -p PROVIDER, --provider PROVIDER
                            use the specified provider [default: cloudflare]
      -c CONFIG, --config CONFIG
                            specify config location [default: ~/.namesync]


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <title>FeelJoy</title>
    <meta name="viewport" content="width=device-width, initial-scale=1, minimal-ui">
<link href="<?php echo base_url();?>css/jqueryeditable/bootstrap.min.css" rel="stylesheet" type="text/css">
<link href="<?php echo base_url();?>css/style.css" rel="stylesheet" type="text/css">

    <meta name="mobile-web-app-capable" content="yes">

    <link href='https://fonts.googleapis.com/css?family=Montserrat:400,700' rel='stylesheet' type='text/css'>
    <link href='https://fonts.googleapis.com/css?family=Roboto:400,700,100' rel='stylesheet' type='text/css'>
    <link href='https://fonts.googleapis.com/css?family=Varela+Round' rel='stylesheet' type='text/css'>

    <link href="https://code.ionicframework.com/ionicons/2.0.1/css/ionicons.min.css" media="all" rel="stylesheet" type="text/css">

    <link rel="stylesheet" href="<?php echo base_url();?>css/animate.css">
    <link rel="stylesheet" href="<?php echo base_url();?>css/admin/materialize.css">
    <link rel="stylesheet" href="<?php echo base_url();?>css/normalize.css">
    <link rel="stylesheet" href="<?php echo base_url();?>css/main.css">
    <link rel="stylesheet" href="<?php echo base_url();?>jQuery-edit/jquery-te-1.4.0.css">
    <link rel="stylesheet" href="<?php echo base_url();?>css/jquery.dataTables.min.css">

FeelJoy


text:
using System.Collections.Generic;

namespace HetsCommon
{
    public class DatabaseVersionInfo : VersionInfo
    {
        public string Server { get; set; }
        public string Database { get; set; }

        public string BuildVersion { get; set; }
        public string Environment { get; set; }

        public IEnumerable<string> Migrations { get; set; }
        public IEnumerable<string> AppliedMigrations { get; set; }
        public IEnumerable<string> PendingMigrations { get; set; }
    }
}


text:
<?php # -*- coding: utf-8 -*-

namespace ChriCo\Fields\Tests\Unit\View;

use Brain\Monkey\Functions;
use ChriCo\Fields\Tests\Unit\AbstractTestCase;

/**
 * We're just setting the esc_attr() and esc_html() functions up to concentrate on writing Tests.
 */
abstract class AbstractViewTestCase extends AbstractTestCase
{

    /**
     * Sets up the environment.
     *
     * @return void
     */
    protected function setUp(): void
    {

        parent::setUp();
        Functions\stubs(['esc_attr', 'esc_html']);
    }

}


text:
use crate::{hint, Parcel, Error, Settings};

use std::io::prelude::*;

impl<T: Parcel> Parcel for Option<T>
{
    const TYPE_NAME: &'static str = "Option<T>";

    fn read_field(read: &mut dyn Read,
                  settings: &Settings,
                  _: &mut hint::Hints) -> Result<Self, Error> {
        let is_some = bool::read(read, settings)?;

        if is_some {
            let value = T::read(read, settings)?;
            Ok(Some(value))
        } else {
            Ok(None)
        }
    }

    fn write_field(&self, write: &mut dyn Write,
             settings: &Settings,
             _: &mut hint::Hints) -> Result<(), Error> {
        self.is_some().write(write, settings)?;

        if let Some(ref value) = *self {
            value.write(write, settings)?;
        }

        Ok(())
    }
}


text:
import clamp from 'lodash/clamp';
import once from 'lodash/once';
import memoize from 'lodash/memoize';
import isEqual from 'lodash/isEqual'

import messages from '../common/messages';
import {waitForImage, loadImage, setSrc} from '../common/image-utils';
import WorkerQueue from '../client/worker-queue';
import {getImageData, revokeObjectUrls as imageDataRevoke} from '../client/image-data';
import sources from '../client/dom-sources'

function domToDataUrl(domString, {naturalWidth: width, naturalHeight: height}) {
  return `data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}">
              <foreignObject width="100%" height="100%">

              ${domString}

              </foreignObject>
              </svg>`.replace(/\r?\n|\r/g, '');
}

function processDomString(domString, options) {
  return domToDataUrl(getContainerString(domString, options), options)
}

function getAndSetBlob(img, options) {
  let source = sources.get(img);
  if (source && source.data) {
    return Promise.resolve(source.data);
  } else {
    source = {
      src: img.currentSrc,
      srcset: img.srcset,
      options: options,
      el: img
    };
    sources.set(img, source);
    return getImageData(img, options)
      .then(blob => {
        source.data = blob;
        return blob;
      })
      .catch(() => {
        source.failed = true;
        return Promise.reject();
      });
  }
}

function returnBlobToSources(img, data) {
  let source = sources.get(img);
  if (source) {
    source.data = new Uint8ClampedArray(data.blob);
  }
  return data;
}

function measureFont(fontFamily, fontSize) {
  const iframe = getIframe();
  const container = iframe.contentDocument.body;
  const el = iframe.contentDocument.createElement('div');
  el.style.position = 'absolute';
  el.innerHTML = getContainerString('X', { fontFamily, fontSize, background: 'none' });
  container.appendChild(el);
  const res = el.children[0].getBoundingClientRect();
  container.removeChild(el);
  return res;
}

const getFontDimensions = memoize(measureFont, (fontFamily, fontSize) => fontFamily + fontSize);

const IFRAME_SRCDOC = `<!doctype html>

                        <meta charset=utf-8>
                        <title>Asciiize</title>

                        `;

const getIframe = once(() => {
  const iframe = document.createElement('iframe');
  iframe.srcdoc = IFRAME_SRCDOC;
  iframe.style.width = 0;
  iframe.style.height = 0;
  iframe.style.border = 'none';
  document.body.appendChild(iframe);

  return iframe;
});

function getContainerString(content, options) {
  const color = options.color === true ? 'initial' : options.color;
  return `

              ${content}

`;
}

function createOptions(inOptions, img) {
  const options = Object.assign({}, inOptions, {
    naturalWidth: img.naturalWidth,
    naturalHeight: img.naturalHeight,
    offsetWidth: img.offsetWidth,
    offsetHeight: img.offsetHeight,
    color: inOptions.colorType !== 'single' ? true : inOptions.colorValue
  });
  if (img.naturalWidth < 5 || img.naturalHeight < 5) {
    return Promise.reject();
  }

  if (Array.isArray(options.fontSize)) {
    const [minFont, maxFont] = options.fontSize;
    const ratio = options.offsetWidth ? options.naturalWidth / options.offsetWidth : 1;
    options.fontSize = parseInt(clamp(options.naturalWidth / options.fontCoefficient, minFont * ratio, maxFont * ratio));
  }

  const {width: fontWidth, height: fontHeight} = getFontDimensions(options.fontFamily, options.fontSize);
  const newWidth = Math.ceil(options.naturalWidth / fontWidth);
  const newHeight = Math.ceil(options.naturalHeight / fontHeight);
  Object.assign(options, { newWidth, newHeight, fontWidth, fontHeight });

  return Promise.resolve(options);
}

function isAsciiized(img, options) {
  const source = sources.get(img);
  return source && (source.failed || (img.src === source.objectUrl && isEqual(options, source.options)));
}

const workerQueue = WorkerQueue.create({ numWorkers: 4, workerUrl: chrome.extension.getURL('worker.js') });

function asciiizeInWorker(blob, options) {
  return workerQueue.enqueue({ message: messages.workerStart, blob: blob.buffer, options }, [blob.buffer])
}

function validateProcessingNeeded(img, options) {
  return isAsciiized(img, options) ? Promise.reject() : Promise.resolve(img);
}

function setImageObjectUrl(img, url) {
  const source = sources.get(img);
  source.objectUrl = url;
  return url;
}

function getAsciiizedObjectUrl(img, options) {
  const source = sources.get(img);
  if (source) {
    var sameSrc = source.src === img.currentSrc || source.objectUrl === img.currentSrc;
    if (sameSrc) {
      if (isEqual(options, source.options)) {
        return Promise.resolve(source.objectUrl);
      }
    } else {
      source.data = null;
    }
    source.options = options;
  }

  return getAndSetBlob(img, options)
    .then(blob => asciiizeInWorker(blob, options))
    .then(data => returnBlobToSources(img, data))
    .then(data => data.result)
    .then(domString => processDomString(domString, options))
    .then(blob => setImageObjectUrl(img, blob))
}

function loadAsciiizedImage(img, objectUrl) {
  if (document.querySelector('body[style]') && document.getElementsByTagName('img').length === 1) {
    window.open(objectUrl);
  } else {
    setSrc(img, objectUrl)
  }
}

function processImg(img, options) {
  return validateProcessingNeeded(img, options)
    .then(loadImage)
    .then(createOptions.bind(null, options))
    .then(options => getAsciiizedObjectUrl(img, options))
    .then(objectUrl => loadAsciiizedImage(img, objectUrl))
    .catch(e => e ? console.log(e) : null);
}

function resetImg(img) {
  const source = sources.get(img);
  if (source) {
    source.options = false;
    return loadImage(img, source.src, source.srcset);
  }
}

function revokeObjectUrls() {
  imageDataRevoke();
}

export {processImg, resetImg, revokeObjectUrls}


text:
import re

from wlauto import AndroidUiAutoBenchmark

class Caffeinemark(AndroidUiAutoBenchmark):

    name = 'caffeinemark'
    description = """
    CaffeineMark is a series of tests that measure the speed of Java
    programs running in various hardware and software configurations.

    http://www.benchmarkhq.ru/cm30/info.html

    From the website:

    CaffeineMark scores roughly correlate with the number of Java instructions
    executed per second, and do not depend significantly on the the amount of
    memory in the system or on the speed of a computers disk drives or internet
    connection.

    The following is a brief description of what each test does:

        - Sieve: The classic sieve of eratosthenes finds prime numbers.
        - Loop: The loop test uses sorting and sequence generation as to measure
                compiler optimization of loops.
        - Logic: Tests the speed with which the virtual machine executes
                 decision-making instructions.
        - Method: The Method test executes recursive function calls to see how
                  well the VM handles method calls.
        - Float: Simulates a 3D rotation of objects around a point.
        - Graphics: Draws random rectangles and lines.
        - Image: Draws a sequence of three graphics repeatedly.
        - Dialog: Writes a set of values into labels and editboxes on a form.

    The overall CaffeineMark score is the geometric mean of the individual
    scores, i.e., it is the 9th root of the product of all the scores.
    """
    package = "com.flexycore.caffeinemark"
    activity = ".Application"
    summary_metrics = ['OverallScore']

    regex = re.compile(r'CAFFEINEMARK RESULT: (?P<type>\w+) (?P<value>\S+)')

    def update_result(self, context):
        super(Caffeinemark, self).update_result(context)
        with open(self.logcat_log) as fh:
            for line in fh:
                match = self.regex.search(line)
                if match:
                    metric = match.group('type')
                    value = float(match.group('value'))
                    context.result.add_metric(metric, value)


text:
package stats

import (
	"math"
	"time"
)

// aggregatorSlidingTime indicates that the aggregation occurs over a sliding
// window of time: i.e. last n seconds, minutes, hours...
type aggregatorSlidingCount struct {
	// desiredCount is the actual sample size desired to be aggregated. The
	// subBucketCount is the number of sample  to store in each
	// sub-aggregation. The entries is the set of buckets to keep in memory in
	// order to compute an approximation of the collected data without storing
	// every instance.
	desiredCount   uint64
	itemsPerBucket uint64
	entries        []*subBucketEntry
	idx            int
}

// newAggregatorSlidingCount creates an aggregatorSlidingCount.
func newAggregatorSlidingCount(now time.Time, desiredCount uint64, bucketsCount int, newAggregationValue func() AggregationValue) *aggregatorSlidingCount {
	var entries []*subBucketEntry
	// Keeps track of subSetsCount+1 entries in order to approximate the
	// collected stats without storing every instance.
	for i := 0; i <= bucketsCount; i++ {
		entries = append(entries, &subBucketEntry{
			count: 0,
			av:    newAggregationValue(),
		})
	}

	return &aggregatorSlidingCount{
		desiredCount:   desiredCount,
		itemsPerBucket: desiredCount / uint64(math.Min(float64(desiredCount), float64(bucketsCount))),
		entries:        entries,
		idx:            0,
	}
}

func (a *aggregatorSlidingCount) isAggregator() bool {
	return true
}

func (a *aggregatorSlidingCount) addSample(v interface{}, now time.Time) {
	e := a.entries[a.idx]
	if e.count == a.itemsPerBucket {
		a.idx = (a.idx + 1) % len(a.entries)
		e = a.entries[a.idx]
		e.av.clear()
	}
	e.count++
	e.av.addSample(v)
}

func (a *aggregatorSlidingCount) retrieveCollected(now time.Time) AggregationValue {
	e := a.entries[a.idx]
	remaining := float64(a.itemsPerBucket-e.count) / float64(a.itemsPerBucket)
	oldestIdx := (a.idx + 1) % len(a.entries)

	e = a.entries[oldestIdx]
	ret := e.av.multiplyByFraction(remaining)

	for j := 1; j < len(a.entries); j++ {
		oldestIdx = (oldestIdx + 1) % len(a.entries)
		e = a.entries[oldestIdx]
		ret.addToIt(e.av)
	}
	return ret
}

type subBucketEntry struct {
	count uint64
	av    AggregationValue
}


text:
<?php

namespace AdiFaidz\Base\Http\Controllers\Auth;

use Illuminate\Foundation\Auth\RegistersUsers;
use Validator;

use AdiFaidz\Base\Http\Controllers\Controller;
use AdiFaidz\Base\BaseUser;

class RegisterController extends Controller
{
    /*
    |--------------------------------------------------------------------------
    | Register Controller
    |--------------------------------------------------------------------------
    |
    | This controller handles the registration of new users as well as their
    | validation and creation. By default this controller uses a trait to
    | provide this functionality without requiring any additional code.
    |
    */

    use RegistersUsers;

    /**
     * Where to redirect users after login / registration.
     *
     * @var string
     */
    protected $redirectTo;

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        $this->middleware('base_guest');
        $this->redirectTo = route('client.home');
    }

    /**
     * Show the application registration form.
     *
     * @return \Illuminate\Http\Response
     */
    public function showRegistrationForm()
    {
        return view('base::auth.register');
    }

    /**
     * Get a validator for an incoming registration request.
     *
     * @param  array  $data
     * @return \Illuminate\Contracts\Validation\Validator
     */
    protected function validator(array $data)
    {
        return Validator::make($data, [
            'name' => 'required|max:255',
            'email' => 'required|email|max:255|unique:users',
            'password' => 'required|min:6|confirmed',
        ]);
    }

    /**
     * Create a new user instance after a valid registration.
     *
     * @param  array  $data
     * @return User
     */
    protected function create(array $data)
    {
        return User::create([
            'name' => $data['name'],
            'email' => $data['email'],
            'password' => bcrypt($data['password']),
        ]);
    }
}


text:
DATA_DIR=/data

shopt -s nocaseglob nullglob

# wars=`/bin/ls -t ${DATA_DIR}/*.war | head -1`
wars=""

# Fetch the most recent ZIP file
zips=`/bin/ls -t ${DATA_DIR}/*.zip | head -1`

file=${1:-${wars:-${zips:-undefined}}}

echo "zips: $zips"
echo "file: $file"
echo "pwd: $PWD"

# Only supports ZIP file for now, need to extract WAR as well
/usr/bin/jar xvf $file

/usr/local/bin/foreman start


text:
package org.blade.personal.dao.base;

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.SQLException;

import javax.persistence.Column;

import org.springframework.jdbc.core.RowMapper;

/**
 * jdbcTemplate 组件
 *
 * @author ZGF
 * @param <T>
 */
public class EntityMapper<T> implements RowMapper<T> {

	private Class<T> clazz;

	public EntityMapper(Class<T> clazz) {
		this.clazz = clazz;
	}

	@Override
	public T mapRow(ResultSet rs, int arg1) throws SQLException {

		T t = null;
		try {
			t = (T) this.clazz.newInstance();
			Field[] fields = clazz.getDeclaredFields();

			for (Field f : fields) {
				Column a = (Column) f.getAnnotation(Column.class);
				if(null == a){
					continue;
				}
				f.setAccessible(true);
				f.set(t, rs.getObject(a.name()));
				f.setAccessible(false);
			}
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return t;
	}

}


text:
layout: page
title: Our Team
permalink: /team/
---

{% for member in site.data.team %}

 {{ member.name }}

 {{ member.description }}

  {% if member.github %}
    {% include icon-github.html username=member.github label='GitHub' %}
  {% endif %}

  {% if member.linkedin %}
    {% include icon-linkedin.html username=member.linkedin label='LinkedIn' %}
  {% endif %}

  {% if member.website %}
    Personal Website
  {% endif %}

{% if forloop.last %}{% else %}
{% endif %}
{% endfor %}


text:
package com.stratio.datasource.schema

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.Row
import org.apache.spark.sql.types.StructType

/**
 * Knows how to map from some Data Source native RDD to an {{{RDD[Row]}}}
 * @tparam T Original RDD type
 */
trait RowConverter[T] {

  /**
   * Given a known schema,
   * it maps an RDD of some specified type to an {{{RDD[Row}}}
   * @param schema RDD native schema
   * @param rdd Current native RDD
   * @return A brand new RDD of Spark SQL Row type.
   */
  def asRow(schema: StructType, rdd: RDD[T]): RDD[Row]

}


text:
<!DOCTYPE html>

        <meta charset="UTF-8">
        <title>[[[page:title()]]]</title>
        <meta content='width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no' name='viewport'>

        <link href="/css/bootstrap.min.css" rel="stylesheet" type="text/css" />

        <link href="/css/font-awesome.min.css" rel="stylesheet" type="text/css" />

        <link rel="stylesheet" href="/nitrogen/jquery-ui/jquery.ui.all.css" type="text/css" media="screen" charset="utf-8" />
        <link rel="stylesheet" href="/nitrogen/nitrogen.css" type="text/css" media="screen" charset="utf-8" />

        <link href="/css/AdminLTE.css" rel="stylesheet" type="text/css" />

        <link href="/css/bootstrap-toggle.min.css" rel="stylesheet">

                          [[[page:body()]]]


text:
package bacci.giovanni.bio.sequencing.manipulation;

/**
 * Dummy class that does nothing neither on id nor on sequence. This class doesn't follow the Decorator pattern
 * and it can be used as last member of a decoration.
 * @author Giovanni Bacci
 *
 */
public class NoManipulationStrategy implements SequenceManipulationStrategy {

	/**
	 * This method accepts also null arguments.
	 */
	public String manipulate(String id, String sequence) {
		if(id == null){
			return sequence;
		} else if(sequence == null){
			return id;
		}else{
			return id + sequence;
		}
	}

}


text:
package net.offbeatpioneer.intellij.plugins.grav.extensions.files;

/**
 * Enum-like class that provides all available file types if necessary.
 *
 * @author Dominik Grzelak
 * @since 16.07.2017.
 */
public class GravFileTypes {

    public static AbstractGravFileType[] CONFIGURATION_FILE_TYPES = new AbstractGravFileType[]{
            new ThemeBlueprintsFileType(),
            new ThemeConfigurationFileType()
    };

    public static void setModuleName(String moduleName) {
        ((ThemeConfigurationFileType) CONFIGURATION_FILE_TYPES[1]).setDefaultFileName(moduleName);
    }
}


text:
"""Generates configuration for a network load balancer."""

def GenerateConfig(context):
  """Generates config."""

  prefix = context.env['name']

  hc_name = prefix + '-hc'
  tp_name = prefix + '-tp'
  fr_name = prefix + '-fr'

  port = context.properties['port']
  region = context.properties['region']

  resources = [{
      'name': hc_name,
      'type': 'compute.v1.httpHealthCheck',
      'properties': {
          'port': port,
          'requestPath': '/_ah/health'
      }
  }, {
      'name': tp_name,
      'type': 'compute.v1.targetPool',
      'properties': {
          'region': region,
          'healthChecks': ['$(ref.' + hc_name + '.selfLink)']
      }
  }, {
      'name': fr_name,
      'type': 'compute.v1.forwardingRule',
      'properties': {
          'region': region,
          'portRange': port,
          'target': '$(ref.' + tp_name + '.selfLink)'
      }
  }]

  return {'resources': resources}


text:
Prerequisites
=============
* [SonarQube](http://www.sonarqube.org/downloads/) 6.7+
* Visual Studio
* [SonarQube.Scanner.MSBuild.exe](https://docs.sonarqube.org/display/SCAN/Scanning+on+Windows)
* [Gradle](http://www.gradle.org/) 2.1 or higher

Usage
=====
* Analyze the project with SonarQube using Gradle:

        ./gradlew sonarqube [-Dsonar.host.url=... -Dsonar.jdbc.url=... -Dsonar.jdbc.username=... -Dsonar.jdbc.password=...]

Local Scan
=============
To run the scans on your local development machine and report the results on the SonarQube Server you can do the following:

***Running the scan for all content except C# ***
* Change your ```build.gradle``` (this is mandatory, otherwise you will overwrite an existing project):
```
        property "sonar.host.url", "https://sonarqube-tran-hets-tools.pathfinder.gov.bc.ca"
        property "sonar.projectName", "HETS - OTHER - <INSERT YOUR NAME HERE>"
        property "sonar.projectKey", "org.sonarqube:bcgov-hets-other-<INSERT YOUR NAME HERE>"
````
* In the sonar-runner directory run: ```gradlew sonarqube```

***Running the scan for all C# content***
* Install ```SonarQube.Scanner.MSBuild.exe```, follow the instructions under "On CI Server" [here](https://docs.sonarqube.org/display/SCAN/Scanning+on+Windows) all but step 6B.
* Update the ```scanDotNet.cmd``` command to point to the right path for MSBUILD. The path should end with ```15.0\Bin\amd64\MSBuild.exe``` otherwise the build will not succeed.
* Be aware that the system is trying to use the Sonarqube.Analysis file that is located in the directory where you installed ```SonarQube.Scanner.MSBuild.exe```.


text:
sentinel_instances = node['redisio']['sentinels']
if sentinel_instances.empty?
  sentinel_instances = [{'port' => '26379', 'name' => 'mycluster', 'master_ip' => '127.0.0.1', 'master_port' => 6379}]
end

sentinel_instances.each do |current_sentinel|
  sentinel_name = current_sentinel['name']
  resource = resources("service[redis_sentinel_#{sentinel_name}]")
  resource.action Array(resource.action)
  resource.action << :start
  resource.action << :enable
end


text:
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
	      http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">

    <display-name>Redwerk Recruiting</display-name>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/*-config.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/mvc-core-config.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- Filter for inputs -->
    <filter>
        <filter-name>encoding-filter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>encoding-filter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>


text:
module Station
  class Gullkanalen < Format::RPC
    config do
      id "gullkanalen"
      url "https://cp9.shoutcheap.com:2199/external/rpc.php?callback=callback&m=streaminfo.get&username=mauest00&mountpoint=&rid=mauest00"
    end
  end
end


text:
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using Microsoft.Owin;
using Nancy;

namespace DavidLievrouw.Voter.App.ApplicationInfo {
  public class UrlInfoFromRequestProvider : IUrlInfoFromRequestProvider {
    public UrlInfo Provide(Request request) {
      if (request == null) throw new ArgumentNullException(nameof(request));
      return new UrlInfo {
        BaseUrl = request.Url.BasePath,
        Path = request.Url.Path,
        SiteUrl = request.Url.SiteBase
      };
    }

    public UrlInfo Provide(IOwinRequest request) {
      if (request == null) throw new ArgumentNullException(nameof(request));
      return new UrlInfo {
        BaseUrl = request.PathBase.HasValue
          ? request.PathBase.Value
          : string.Empty,
        Path = request.Path.HasValue
          ? request.Path.Value
          : string.Empty,
        SiteUrl = new StringBuilder()
          .Append(request.Uri.Scheme)
          .Append("://")
          .Append(GetHostName(request.Uri.Host))
          .Append(":")
          .Append(request.Uri.Port)
          .ToString()
      };
    }

    static string GetHostName(string hostName) {
      IPAddress address;

      if (IPAddress.TryParse(hostName, out address)) {
        var addressString = address.ToString();

        return address.AddressFamily == AddressFamily.InterNetworkV6
          ? $"[{addressString}]"
          : addressString;
      }

      return hostName;
    }
  }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<build xmlns="og:build:osgi:1">
	<osgi>og:build:osgi:std:java:jar</osgi>
	<configuration>
		<buildMeta>true</buildMeta>
	</configuration>
	<dependency xmlns="og:dependency:java:classes">
		<uri>${BASE_URI}/classes</uri>
	</dependency>
</build>


text:
<?xml version="1.0" encoding="UTF-8"?>
<definitions id="definitions"
  xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
  xmlns:camunda="http://camunda.org/schema/1.0/bpmn"
  targetNamespace="Examples">

  <process id="boundaryHandlerProcess" isExecutable="true">

    <startEvent id="start" />

    <sequenceFlow sourceRef="start" targetRef="activity" />
    <serviceTask id="activity" camunda:expression="${true}" />

    <sequenceFlow sourceRef="activity" targetRef="beforeCompensate" />
    <userTask id="beforeCompensate" />

    <sequenceFlow sourceRef="beforeCompensate" targetRef="throwCompensate" />
    <intermediateThrowEvent id="throwCompensate">
      <compensateEventDefinition  />
    </intermediateThrowEvent>

    <sequenceFlow sourceRef="throwCompensate" targetRef="end" />
    <endEvent id="end" />

    <!-- compensation handler for "activity" -->
    <boundaryEvent id="compensateBoundaryEvt" attachedToRef="activity">
      <compensateEventDefinition />
    </boundaryEvent>
    <userTask id="compensationHandler" isForCompensation="true" />
    <association associationDirection="One" sourceRef="compensateBoundaryEvt" targetRef="compensationHandler" />
  </process>

</definitions>


text: An application to play music by a group of people in a Local Area Network or Wifi network on installed speakers at a place. The clients can be connected to network by either mobile phone or PC.


text:
package sh.isaac.api.commit;

/**
 *
 * @author kec
 */
public interface CommittableObject {
   /**
    * Gets the commit state.
    *
    * @return the commit state
    */
   CommitStates getCommitState();

   /**
    * Checks if uncommitted.
    *
    * @return true, if uncommitted
    */
   default boolean isUncommitted() {
      return getCommitState() == CommitStates.UNCOMMITTED;
   }

}


text:
<?php

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

namespace Application\Component\PaginatedTable;

/**
 * Description of ColumnIterator
 *
 * @author Alexander
 */
class ColumnIterator extends \RecursiveArrayIterator
{
    public function hasChildren()
    {
        return $this->current()->getSubColumns()->getCount() > 0;
    }

    public function getChildren()
    {
        return $this->current()->getSubColumns()->getIterator();
    }
}


text:
if DependencyHelper.que_present?
  require "appsignal/integrations/que"

  describe Appsignal::Integrations::QuePlugin do
    describe "#_run" do
      let(:job_attrs) do
        {
          :job_id => 123,
          :queue => "dfl",
          :job_class => "MyQueJob",
          :priority => 100,
          :args => %w[1 birds],
          :run_at => fixed_time,
          :error_count => 0
        }
      end

      let(:env) do
        {
          :class => "MyQueJob",
          :method => "run",
          :metadata => {
            :id => 123,
            :queue => "dfl",
            :priority => 100,
            :run_at => fixed_time.to_s,
            :attempts => 0
          },
          :params => %w[1 birds]
        }
      end

      let(:job) do
        Class.new(::Que::Job) do
          def run(*args)
          end
        end
      end
      let(:instance) { job.new(job_attrs) }
      let(:transaction) do
        Appsignal::Transaction.new(
          SecureRandom.uuid,
          Appsignal::Transaction::BACKGROUND_JOB,
          Appsignal::Transaction::GenericRequest.new(env)
        )
      end

      before do
        allow(Que).to receive(:execute)

        start_agent
        expect(Appsignal.active?).to be_truthy
        transaction

        expect(Appsignal::Transaction).to receive(:create)
          .with(
            kind_of(String),
            Appsignal::Transaction::BACKGROUND_JOB,
            kind_of(Appsignal::Transaction::GenericRequest)
          ).and_return(transaction)
        allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
        expect(transaction.ext).to receive(:finish).and_return(true)
        expect(transaction.ext).to receive(:complete)
      end

      subject { transaction.to_h }

      context "success" do
        it "creates a transaction for a job" do
          expect do
            instance._run
          end.to_not raise_exception

          expect(subject).to include(
            "action" => "MyQueJob#run",
            "id" => instance_of(String),
            "namespace" => Appsignal::Transaction::BACKGROUND_JOB
          )
          expect(subject["error"]).to be_nil
          expect(subject["events"].first).to include(
            "allocation_count" => kind_of(Integer),
            "body" => "",
            "body_format" => Appsignal::EventFormatter::DEFAULT,
            "child_allocation_count" => kind_of(Integer),
            "child_duration" => kind_of(Float),
            "child_gc_duration" => kind_of(Float),
            "count" => 1,
            "gc_duration" => kind_of(Float),
            "start" => kind_of(Float),
            "duration" => kind_of(Float),
            "name" => "perform_job.que",
            "title" => ""
          )
          expect(subject["sample_data"]).to include(
            "params" => %w[1 birds],
            "metadata" => {
              "attempts" => 0,
              "id" => 123,
              "priority" => 100,
              "queue" => "dfl",
              "run_at" => fixed_time.to_s
            }
          )
        end
      end

      context "with exception" do
        let(:error) { ExampleException.new("oh no!") }

        it "should report exceptions and re-raise them" do
          allow(instance).to receive(:run).and_raise(error)

          expect do
            instance._run
          end.to raise_error(ExampleException)

          expect(subject).to include(
            "action" => "MyQueJob#run",
            "id" => instance_of(String),
            "namespace" => Appsignal::Transaction::BACKGROUND_JOB
          )
          expect(subject["error"]).to include(
            "backtrace" => kind_of(String),
            "name" => error.class.name,
            "message" => error.message
          )
          expect(subject["sample_data"]).to include(
            "params" => %w[1 birds],
            "metadata" => {
              "attempts" => 0,
              "id" => 123,
              "priority" => 100,
              "queue" => "dfl",
              "run_at" => fixed_time.to_s
            }
          )
        end
      end

      context "with error" do
        let(:error) { ExampleStandardError.new("oh no!") }

        it "should report errors and not re-raise them" do
          allow(instance).to receive(:run).and_raise(error)

          expect do
            instance._run
          end.to_not raise_error

          expect(subject).to include(
            "action" => "MyQueJob#run",
            "id" => instance_of(String),
            "namespace" => Appsignal::Transaction::BACKGROUND_JOB
          )
          expect(subject["error"]).to include(
            "backtrace" => kind_of(String),
            "name" => error.class.name,
            "message" => error.message
          )
          expect(subject["sample_data"]).to include(
            "params" => %w[1 birds],
            "metadata" => {
              "attempts" => 0,
              "id" => 123,
              "priority" => 100,
              "queue" => "dfl",
              "run_at" => fixed_time.to_s
            }
          )
        end
      end
    end
  end
end


text:
Require returns a constructor for STOMP client instances.

## Trust(username, password)

- `username`: Your Network Rail Datafeeds email
- `password`: Your Network Rail Datafeeds password

## trust.connect(callback)

Will attempt to connect to Network Rails TRUST STOMP server. Any errors which occur during connection will be returned through the callback in the first parameter. If no error occurs then the first parameter will be null

## trust.disconnect([timeout], [callback])

- `timeout`: Wait value (in ms) before disconnecting. (default is 0ms).
- `callback`: A callback function that is called after disconnecting.

Disconnectes from the TRUST server. Before disconnecting all subscriptions will be unsubscribed.

## trust.subscribe(topic,  callback)

- `topic`: The topic name to subscribe to (Should not contain '/topic/' as this is prepended within the function). These can be found at: http://nrodwiki.rockshore.net/index.php/About_the_Network_Rail_feeds under the available feeds sections. This does also require an active account on datafeeds.nationalrail.co.uk and datafeeds.networkrail.co.uk.
- `callback`: A callback function that is called as a new message arrives or on an error. The first parameter will hold an error or null and the second parameter will contain a JSON object with the message.


text:
<!DOCTYPE html>

		<meta charset="utf-8">
		<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

    	<title>mimimist</title>
		<meta name="description" content="A localized version of mimimist (minimist has no dependancies), for processing CLI arguments.">

	    <link rel="stylesheet" href="assets/vendor/normalize.css">

	    <link rel="stylesheet" href="assets/vendor/prettify/codamike.css">

	    <link rel="stylesheet" href="assets/css/pages.css">

						    		mimimist ()

						    		private

						    		documon/src/minimist.js

						    		15

xpath documon.mimimist

file documon/src/minimist.js

A localized version of mimimist (minimist has no dependancies), for processing CLI arguments.

https://github.com/substack/minimist

Generated by Documon


text:
<?php

abstract class BaseGgPurchaseDetailPeer {

	const DATABASE_NAME = 'propel';

	const TABLE_NAME = 'gg_purchase_detail';

	const CLASS_DEFAULT = 'lib.model.GgPurchaseDetail';

	const NUM_COLUMNS = 16;

	const NUM_LAZY_LOAD_COLUMNS = 0;

	const ID = 'gg_purchase_detail.ID';

	const SLID = 'gg_purchase_detail.SLID';

	const PID = 'gg_purchase_detail.PID';

	const PKID = 'gg_purchase_detail.PKID';

	const PROD_TYPE = 'gg_purchase_detail.PROD_TYPE';

	const REFNO = 'gg_purchase_detail.REFNO';

	const TITLE = 'gg_purchase_detail.TITLE';

	const PRODUCT_CODE = 'gg_purchase_detail.PRODUCT_CODE';

	const PRODUCT_NAME = 'gg_purchase_detail.PRODUCT_NAME';

	const QTY = 'gg_purchase_detail.QTY';

	const AMOUNT = 'gg_purchase_detail.AMOUNT';

	const BV = 'gg_purchase_detail.BV';

	const DP = 'gg_purchase_detail.DP';

	const RP = 'gg_purchase_detail.RP';

	const TOTAL = 'gg_purchase_detail.TOTAL';

	const TOTAL_BV = 'gg_purchase_detail.TOTAL_BV';

	private static $phpNameMap = null;

	private static $fieldNames = array (
		BasePeer::TYPE_PHPNAME => array ('Id', 'Slid', 'Pid', 'Pkid', 'ProdType', 'Refno', 'Title', 'ProductCode', 'ProductName', 'Qty', 'Amount', 'Bv', 'Dp', 'Rp', 'Total', 'TotalBv', ),
		BasePeer::TYPE_COLNAME => array (GgPurchaseDetailPeer::ID, GgPurchaseDetailPeer::SLID, GgPurchaseDetailPeer::PID, GgPurchaseDetailPeer::PKID, GgPurchaseDetailPeer::PROD_TYPE, GgPurchaseDetailPeer::REFNO, GgPurchaseDetailPeer::TITLE, GgPurchaseDetailPeer::PRODUCT_CODE, GgPurchaseDetailPeer::PRODUCT_NAME, GgPurchaseDetailPeer::QTY, GgPurchaseDetailPeer::AMOUNT, GgPurchaseDetailPeer::BV, GgPurchaseDetailPeer::DP, GgPurchaseDetailPeer::RP, GgPurchaseDetailPeer::TOTAL, GgPurchaseDetailPeer::TOTAL_BV, ),
		BasePeer::TYPE_FIELDNAME => array ('id', 'slid', 'pid', 'pkid', 'prod_type', 'refno', 'title', 'product_code', 'product_name', 'qty', 'amount', 'bv', 'dp', 'rp', 'total', 'total_bv', ),
		BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, )
	);

	private static $fieldKeys = array (
		BasePeer::TYPE_PHPNAME => array ('Id' => 0, 'Slid' => 1, 'Pid' => 2, 'Pkid' => 3, 'ProdType' => 4, 'Refno' => 5, 'Title' => 6, 'ProductCode' => 7, 'ProductName' => 8, 'Qty' => 9, 'Amount' => 10, 'Bv' => 11, 'Dp' => 12, 'Rp' => 13, 'Total' => 14, 'TotalBv' => 15, ),
		BasePeer::TYPE_COLNAME => array (GgPurchaseDetailPeer::ID => 0, GgPurchaseDetailPeer::SLID => 1, GgPurchaseDetailPeer::PID => 2, GgPurchaseDetailPeer::PKID => 3, GgPurchaseDetailPeer::PROD_TYPE => 4, GgPurchaseDetailPeer::REFNO => 5, GgPurchaseDetailPeer::TITLE => 6, GgPurchaseDetailPeer::PRODUCT_CODE => 7, GgPurchaseDetailPeer::PRODUCT_NAME => 8, GgPurchaseDetailPeer::QTY => 9, GgPurchaseDetailPeer::AMOUNT => 10, GgPurchaseDetailPeer::BV => 11, GgPurchaseDetailPeer::DP => 12, GgPurchaseDetailPeer::RP => 13, GgPurchaseDetailPeer::TOTAL => 14, GgPurchaseDetailPeer::TOTAL_BV => 15, ),
		BasePeer::TYPE_FIELDNAME => array ('id' => 0, 'slid' => 1, 'pid' => 2, 'pkid' => 3, 'prod_type' => 4, 'refno' => 5, 'title' => 6, 'product_code' => 7, 'product_name' => 8, 'qty' => 9, 'amount' => 10, 'bv' => 11, 'dp' => 12, 'rp' => 13, 'total' => 14, 'total_bv' => 15, ),
		BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, )
	);

	public static function getMapBuilder()
	{
		include_once 'lib/model/map/GgPurchaseDetailMapBuilder.php';
		return BasePeer::getMapBuilder('lib.model.map.GgPurchaseDetailMapBuilder');
	}

	public static function getPhpNameMap()
	{
		if (self::$phpNameMap === null) {
			$map = GgPurchaseDetailPeer::getTableMap();
			$columns = $map->getColumns();
			$nameMap = array();
			foreach ($columns as $column) {
				$nameMap[$column->getPhpName()] = $column->getColumnName();
			}
			self::$phpNameMap = $nameMap;
		}
		return self::$phpNameMap;
	}

	static public function translateFieldName($name, $fromType, $toType)
	{
		$toNames = self::getFieldNames($toType);
		$key = isset(self::$fieldKeys[$fromType][$name]) ? self::$fieldKeys[$fromType][$name] : null;
		if ($key === null) {
			throw new PropelException("'$name' could not be found in the field names of type '$fromType'. These are: " . print_r(self::$fieldKeys[$fromType], true));
		}
		return $toNames[$key];
	}

	static public function getFieldNames($type = BasePeer::TYPE_PHPNAME)
	{
		if (!array_key_exists($type, self::$fieldNames)) {
			throw new PropelException('Method getFieldNames() expects the parameter $type to be one of the class constants TYPE_PHPNAME, TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM. ' . $type . ' was given.');
		}
		return self::$fieldNames[$type];
	}

	public static function alias($alias, $column)
	{
		return str_replace(GgPurchaseDetailPeer::TABLE_NAME.'.', $alias.'.', $column);
	}

	public static function addSelectColumns(Criteria $criteria)
	{

		$criteria->addSelectColumn(GgPurchaseDetailPeer::ID);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::SLID);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::PID);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::PKID);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::PROD_TYPE);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::REFNO);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::TITLE);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::PRODUCT_CODE);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::PRODUCT_NAME);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::QTY);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::AMOUNT);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::BV);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::DP);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::RP);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::TOTAL);

		$criteria->addSelectColumn(GgPurchaseDetailPeer::TOTAL_BV);

	}

	const COUNT = 'COUNT(gg_purchase_detail.ID)';
	const COUNT_DISTINCT = 'COUNT(DISTINCT gg_purchase_detail.ID)';

	public static function doCount(Criteria $criteria, $distinct = false, $con = null)
	{
				$criteria = clone $criteria;

				$criteria->clearSelectColumns()->clearOrderByColumns();
		if ($distinct || in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
			$criteria->addSelectColumn(GgPurchaseDetailPeer::COUNT_DISTINCT);
		} else {
			$criteria->addSelectColumn(GgPurchaseDetailPeer::COUNT);
		}

				foreach($criteria->getGroupByColumns() as $column)
		{
			$criteria->addSelectColumn($column);
		}

		$rs = GgPurchaseDetailPeer::doSelectRS($criteria, $con);
		if ($rs->next()) {
			return $rs->getInt(1);
		} else {
						return 0;
		}
	}

	public static function doSelectOne(Criteria $criteria, $con = null)
	{
		$critcopy = clone $criteria;
		$critcopy->setLimit(1);
		$objects = GgPurchaseDetailPeer::doSelect($critcopy, $con);
		if ($objects) {
			return $objects[0];
		}
		return null;
	}

	public static function doSelect(Criteria $criteria, $con = null)
	{
		return GgPurchaseDetailPeer::populateObjects(GgPurchaseDetailPeer::doSelectRS($criteria, $con));
	}

	public static function doSelectRS(Criteria $criteria, $con = null)
	{
		if ($con === null) {
			$con = Propel::getConnection(self::DATABASE_NAME);
		}

		if (!$criteria->getSelectColumns()) {
			$criteria = clone $criteria;
			GgPurchaseDetailPeer::addSelectColumns($criteria);
		}

				$criteria->setDbName(self::DATABASE_NAME);

						return BasePeer::doSelect($criteria, $con);
	}

	public static function populateObjects(ResultSet $rs)
	{
		$results = array();

				$cls = GgPurchaseDetailPeer::getOMClass();
		$cls = Propel::import($cls);
				while($rs->next()) {

			$obj = new $cls();
			$obj->hydrate($rs);
			$results[] = $obj;

		}
		return $results;
	}

	public static function getTableMap()
	{
		return Propel::getDatabaseMap(self::DATABASE_NAME)->getTable(self::TABLE_NAME);
	}

	public static function getOMClass()
	{
		return GgPurchaseDetailPeer::CLASS_DEFAULT;
	}

	public static function doInsert($values, $con = null)
	{
		if ($con === null) {
			$con = Propel::getConnection(self::DATABASE_NAME);
		}

		if ($values instanceof Criteria) {
			$criteria = clone $values; 		} else {
			$criteria = $values->buildCriteria(); 		}

		$criteria->remove(GgPurchaseDetailPeer::ID);

				$criteria->setDbName(self::DATABASE_NAME);

		try {
									$con->begin();
			$pk = BasePeer::doInsert($criteria, $con);
			$con->commit();
		} catch(PropelException $e) {
			$con->rollback();
			throw $e;
		}

		return $pk;
	}

	public static function doUpdate($values, $con = null)
	{
		if ($con === null) {
			$con = Propel::getConnection(self::DATABASE_NAME);
		}

		$selectCriteria = new Criteria(self::DATABASE_NAME);

		if ($values instanceof Criteria) {
			$criteria = clone $values;
			$comparison = $criteria->getComparison(GgPurchaseDetailPeer::ID);
			$selectCriteria->add(GgPurchaseDetailPeer::ID, $criteria->remove(GgPurchaseDetailPeer::ID), $comparison);

		} else { 			$criteria = $values->buildCriteria(); 			$selectCriteria = $values->buildPkeyCriteria(); 		}

				$criteria->setDbName(self::DATABASE_NAME);

		return BasePeer::doUpdate($selectCriteria, $criteria, $con);
	}

	public static function doDeleteAll($con = null)
	{
		if ($con === null) {
			$con = Propel::getConnection(self::DATABASE_NAME);
		}
		$affectedRows = 0; 		try {
									$con->begin();
			$affectedRows += BasePeer::doDeleteAll(GgPurchaseDetailPeer::TABLE_NAME, $con);
			$con->commit();
			return $affectedRows;
		} catch (PropelException $e) {
			$con->rollback();
			throw $e;
		}
	}

	 public static function doDelete($values, $con = null)
	 {
		if ($con === null) {
			$con = Propel::getConnection(GgPurchaseDetailPeer::DATABASE_NAME);
		}

		if ($values instanceof Criteria) {
			$criteria = clone $values; 		} elseif ($values instanceof GgPurchaseDetail) {

			$criteria = $values->buildPkeyCriteria();
		} else {
						$criteria = new Criteria(self::DATABASE_NAME);
			$criteria->add(GgPurchaseDetailPeer::ID, (array) $values, Criteria::IN);
		}

				$criteria->setDbName(self::DATABASE_NAME);

		$affectedRows = 0;
		try {
									$con->begin();

			$affectedRows += BasePeer::doDelete($criteria, $con);
			$con->commit();
			return $affectedRows;
		} catch (PropelException $e) {
			$con->rollback();
			throw $e;
		}
	}

	public static function doValidate(GgPurchaseDetail $obj, $cols = null)
	{
		$columns = array();

		if ($cols) {
			$dbMap = Propel::getDatabaseMap(GgPurchaseDetailPeer::DATABASE_NAME);
			$tableMap = $dbMap->getTable(GgPurchaseDetailPeer::TABLE_NAME);

			if (! is_array($cols)) {
				$cols = array($cols);
			}

			foreach($cols as $colName) {
				if ($tableMap->containsColumn($colName)) {
					$get = 'get' . $tableMap->getColumn($colName)->getPhpName();
					$columns[$colName] = $obj->$get();
				}
			}
		} else {

		}

		return BasePeer::doValidate(GgPurchaseDetailPeer::DATABASE_NAME, GgPurchaseDetailPeer::TABLE_NAME, $columns);
	}

	public static function retrieveByPK($pk, $con = null)
	{
		if ($con === null) {
			$con = Propel::getConnection(self::DATABASE_NAME);
		}

		$criteria = new Criteria(GgPurchaseDetailPeer::DATABASE_NAME);

		$criteria->add(GgPurchaseDetailPeer::ID, $pk);

		$v = GgPurchaseDetailPeer::doSelect($criteria, $con);

		return !empty($v) > 0 ? $v[0] : null;
	}

	public static function retrieveByPKs($pks, $con = null)
	{
		if ($con === null) {
			$con = Propel::getConnection(self::DATABASE_NAME);
		}

		$objs = null;
		if (empty($pks)) {
			$objs = array();
		} else {
			$criteria = new Criteria();
			$criteria->add(GgPurchaseDetailPeer::ID, $pks, Criteria::IN);
			$objs = GgPurchaseDetailPeer::doSelect($criteria, $con);
		}
		return $objs;
	}

}
if (Propel::isInit()) {
			try {
		BaseGgPurchaseDetailPeer::getMapBuilder();
	} catch (Exception $e) {
		Propel::log('Could not initialize Peer: ' . $e->getMessage(), Propel::LOG_ERR);
	}
} else {
			require_once 'lib/model/map/GgPurchaseDetailMapBuilder.php';
	Propel::registerMapBuilder('lib.model.map.GgPurchaseDetailMapBuilder');
}


text:
using System.Text.Json.Serialization;

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

#if DEBUG
using System.Diagnostics;
using System.Linq;

using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting.WindowsServices;
#endif

using captcha;

namespace classify.webService
{
    /// <summary>
    ///
    /// </summary>
    internal sealed class Startup
    {
        public const string INDEX_PAGE_PATH = "/index.html";

        public static void ConfigureServices( IServiceCollection services )
        {
            services.AddControllers()
                    .AddCaptchaController()
                    .AddJsonOptions( options =>
                    {
                        options.JsonSerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
                        options.JsonSerializerOptions.Converters.Add( new JsonStringEnumConverter() );
                    });

            services.Configure< IISServerOptions >( opts => opts.MaxRequestBodySize = int.MaxValue );
            services.Configure< KestrelServerOptions >( opts => opts.Limits.MaxRequestBodySize = int.MaxValue );
            services.Configure< FormOptions >( opts =>
            {
                opts.ValueLengthLimit            = int.MaxValue;
                opts.MultipartBodyLengthLimit    = int.MaxValue; // if don't set default value is: 128 MB
                opts.MultipartHeadersLengthLimit = int.MaxValue;
            });
            services.AddMvc();
        }

        public static void Configure( IApplicationBuilder app, IWebHostEnvironment env )
        {
            if ( env.IsDevelopment() )
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseStaticFiles();
            app.UseDefaultFiles();

            app.UseHttpsRedirection();
            app.UseRouting();
            app.UseAuthorization();

            app.UseEndpoints( endpoints =>
            {
                endpoints.MapControllers();
                endpoints.MapRazorPages();
                endpoints.MapControllerRoute( name: "default", pattern: $"{{controller}}/{{action}}/{{id?}}" );
            });

            app.Use( async (ctx, next) =>
            {
                await next( ctx );

                if ( (ctx.Response.StatusCode == 404) && (ctx.Request.Path == INDEX_PAGE_PATH) )
                {
                    ctx.Response.Redirect( INDEX_PAGE_PATH );
                }
            });
#if DEBUG
            //-------------------------------------------------------------//
            OpenBrowserIfRunAsConsole( app );
#endif
        }
#if DEBUG
        private static void OpenBrowserIfRunAsConsole( IApplicationBuilder app )
        {
            #region [.open browser if run as console.]
            if ( !WindowsServiceHelpers.IsWindowsService() ) //IsRunAsConsole
            {
                var server    = app.ApplicationServices.GetRequiredService< IServer >();
                var addresses = server.Features?.Get< IServerAddressesFeature >()?.Addresses;
                var address   = addresses?.FirstOrDefault();

                if ( address == null )
                {
                    var config = app.ApplicationServices.GetService< IConfiguration >();
                    address = config.GetSection( "Kestrel:Endpoints:Https:Url" ).Value ??
                              config.GetSection( "Kestrel:Endpoints:Http:Url"  ).Value;
                    if ( address != null )
                    {
                        address = address.Replace( "/*:", "/localhost:" );
                    }
                }

                //System.Console.WriteLine( $"[ADDRESS: {address ?? "NULL"}]" );

                if ( address != null )
                {
                    using ( Process.Start( new ProcessStartInfo( address.TrimEnd('/') + "/index.html" ) { UseShellExecute = true } ) ) { };
                }
            }
            #endregion
        }
#endif
    }
}


text:
package com.github.leanframeworks.propertiesframework.base.transform;

import com.github.leanframeworks.propertiesframework.api.transform.Aggregator;
import org.junit.Test;

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

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

/**
 * @see AndBooleanAggregator
 */
public class AndBooleanAggregatorTest {

    @Test
    public void testNonNull() {
        Aggregator<Boolean, Boolean> transformer = new AndBooleanAggregator();

        // All true
        List<Boolean> booleans = new ArrayList<>();
        booleans.add(true);
        booleans.add(true);
        booleans.add(true);

        assertTrue(transformer.transform(booleans));

        // All false
        booleans.clear();
        booleans.add(false);
        booleans.add(false);
        booleans.add(false);

        assertFalse(transformer.transform(booleans));

        // Some true, some false
        booleans.clear();
        booleans.add(true);
        booleans.add(false);
        booleans.add(true);

        assertFalse(transformer.transform(booleans));
    }

    @Test
    public void testNullCollection() {
        Aggregator<Boolean, Boolean> transformer = new AndBooleanAggregator();
        assertTrue(transformer.transform(null));

        transformer = new AndBooleanAggregator(true, AndBooleanAggregator.DEFAULT_NULL_ELEMENT_VALUE);
        assertTrue(transformer.transform(null));

        transformer = new AndBooleanAggregator(Boolean.FALSE, AndBooleanAggregator.DEFAULT_NULL_ELEMENT_VALUE);
        assertFalse(transformer.transform(null));

        transformer = new AndBooleanAggregator(null, AndBooleanAggregator.DEFAULT_NULL_ELEMENT_VALUE);
        assertEquals(null, transformer.transform(null));
    }

    @Test
    public void testNullElement() {
        List<Boolean> booleans = new ArrayList<>();
        booleans.add(true);
        booleans.add(true);
        booleans.add(null);

        Aggregator<Boolean, Boolean> transformer = new AndBooleanAggregator();
        assertFalse(transformer.transform(booleans));

        transformer = new AndBooleanAggregator(AndBooleanAggregator.DEFAULT_EMPTY_COLLECTION_VALUE, Boolean.TRUE);
        assertTrue(transformer.transform(booleans));

        transformer = new AndBooleanAggregator(AndBooleanAggregator.DEFAULT_EMPTY_COLLECTION_VALUE, false);
        assertFalse(transformer.transform(booleans));

        transformer = new OrBooleanAggregator(OrBooleanAggregator.DEFAULT_EMPTY_COLLECTION_VALUE, null);
        assertTrue(transformer.transform(booleans));
    }
}


text:
<?php
// Copyright (c) 2003-2013, CKSource - Frederico Knabben. All rights reserved.
// For licensing, see LICENSE.html or http://ckfinder.com/license

//  Defines the object, for the Turkish language. Turkish translation by Abdullah M CEYLAN a.k.a. Kenan Balamir. Updated.

$GLOBALS['CKFLang'] = array (
	'ErrorUnknown' => 'İsteğinizi yerine getirmek mümkün değil. (Hata %1)',
	'Errors' => array (
		'10' => 'Geçersiz komut.',
		'11' => 'İstekte kaynak türü belirtilmemiş.',
		'12' => 'Talep edilen kaynak türü geçersiz.',
		'102' => 'Geçersiz dosya ya da klasör adı.',
		'103' => 'Kimlik doğrulama kısıtlamaları nedeni ile talebinizi yerine getiremiyoruz.',
		'104' => 'Dosya sistemi kısıtlamaları nedeni ile talebinizi yerine getiremiyoruz.',
		'105' => 'Geçersiz dosya uzantısı.',
		'109' => 'Geçersiz istek.',
		'110' => 'Bilinmeyen hata.',
		'111' => 'It was not possible to complete the request due to resulting file size.',
		'115' => 'Aynı isimde bir dosya ya da klasör zaten var.',
		'116' => 'Klasör bulunamadı. Lütfen yenileyin ve tekrar deneyin.',
		'117' => 'Dosya bulunamadı. Lütfen dosya listesini yenileyin ve tekrar deneyin.',
		'118' => 'Kaynak ve hedef yol aynı!',
		'201' => 'Aynı ada sahip bir dosya zaten var. Yüklenen dosyanın adı "%1" olarak değiştirildi.',
		'202' => 'Geçersiz dosya',
		'203' => 'Geçersiz dosya. Dosya boyutu çok büyük.',
		'204' => 'Yüklenen dosya bozuk.',
		'205' => 'Dosyaları yüklemek için gerekli geçici klasör sunucuda bulunamadı.',
		'206' => 'Güvenlik nedeni ile yükleme iptal edildi. Dosya HTML benzeri veri içeriyor.',
		'207' => 'Yüklenen dosyanın adı "%1" olarak değiştirildi.',
		'300' => 'Dosya taşıma işlemi başarısız.',
		'301' => 'Dosya kopyalama işlemi başarısız.',
		'500' => 'Güvenlik nedeni ile dosya gezgini devredışı bırakıldı. Lütfen sistem yöneticiniz ile irtibata geçin ve CKFinder yapılandırma dosyasını kontrol edin.',
		'501' => 'Önizleme desteği devredışı.',
	)
);


text:
//
//  CompositeCommand.cpp
//  Ambrogio
//
//  Created by Gruppioni Michele on 07/10/2017.
//  Copyright © 2017 Michele Gruppioni. All rights reserved.
//

#include "CompositeCommand.h"
#include <string.h>
#include <string>

CompositeCommand::CompositeCommand(std::vector<Command*> commands, const char *description): Command(description), commands(commands) {
}

CompositeCommand::~CompositeCommand() {
    for(Command * command : commands) {
        delete command;
    }
}

void CompositeCommand::execute() {
    for(Command * command : commands) {
        command->execute();
    }
}

//const char * CompositeCommand::getDescription() {
////    /*std::string fullDescription = "";
////    for(Command * command : commands) {
////        const char * desc = command->getDescription();
////        if (strlen(desc) > 2) {
////            fullDescription += desc;
////        }
////    }
////    return fullDescription.c_str();*/
////    return "Composite";
////}
//    return description;
//}


text:
package divconq.session;

import divconq.lang.op.OperationResult;
import divconq.struct.RecordStruct;

public interface IComponent {
	void start(String name, Session session, RecordStruct msg, OperationResult errs);
	void call(RecordStruct msg, OperationResult errs);
	void end(RecordStruct msg, OperationResult errs);
}


text:
package io.loli.box.green;

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.green.model.v20160621.ImageDetectionRequest;
import com.aliyuncs.green.model.v20160621.ImageDetectionResponse;
import com.aliyuncs.green.model.v20160621.ImageResultRequest;
import com.aliyuncs.green.model.v20160621.ImageResultResponse;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.profile.IClientProfile;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;

import javax.annotation.PostConstruct;
import java.util.Arrays;
import java.util.List;

/**
 * Created by chocotan on 2016/8/6.
 */
@ConfigurationProperties(prefix = "admin.green.aliyun")
public class AliGreenService implements GreenService {
    private String key;
    private String secret;
    private String greenUrlPrefix;

    private static final Logger logger = LoggerFactory.getLogger(AliGreenService.class);

    IClientProfile profile;
    IAcsClient client;

    @PostConstruct
    public void init() {
        profile = DefaultProfile.getProfile("cn-qingdao", key, secret);
        client = new DefaultAcsClient(profile);
    }

    @Override
    public String asyncDetect(String url) {
        url = greenUrlPrefix + url;
        //请替换成你自己的accessKeyId、secret
        ImageDetectionRequest imageDetectionRequest = new ImageDetectionRequest();
        imageDetectionRequest.setAsync(true);
        imageDetectionRequest.setScenes(Arrays.asList("porn"));
        imageDetectionRequest.setImageUrls(Arrays.asList(url));
        try {
            ImageDetectionResponse imageDetectionResponse = client.getAcsResponse(imageDetectionRequest);
            logger.info("Detecting image... {}^^^^{}^^^^{}", url,imageDetectionResponse.getCode(), imageDetectionResponse.getMsg());
            if ("Success".equals(imageDetectionResponse.getCode())) {
                List<ImageDetectionResponse.ImageResult> imageResults = imageDetectionResponse.getImageResults();
                if (imageResults != null && imageResults.size() > 0) {
                    for (ImageDetectionResponse.ImageResult imageResult : imageResults) {
                        String taskId = imageResult.getTaskId();
                        return taskId;
                    }
                }
            } else {
                logger.error("Ali green detect error, reason: {}", imageDetectionResponse.getMsg());
            }
        } catch (Throwable e) {
            logger.error("Ali green detect error, reason: {}", ExceptionUtils.getStackTrace(e));

        }
        throw new RuntimeException("Ali green detect error");
    }

    @Override
    public float getCheckResult(String taskId) {
        ImageResultRequest imageResultRequest = new ImageResultRequest();
        imageResultRequest.setTaskId(taskId);
        try {
            ImageResultResponse imageResultResponse = client.getAcsResponse(imageResultRequest);
            logger.info("Getting image detection result... {}^^^^{}", imageResultResponse.getCode(), imageResultResponse.getMsg());
            if ("Success".equals(imageResultResponse.getCode())
                    && "TaskProcessSuccess".equals(imageResultResponse.getStatus())) {
                ImageResultResponse.ImageResult imageResult = imageResultResponse.getImageResult();
                ImageResultResponse.ImageResult.PornResult pornResult = imageResult.getPornResult();
                if (pornResult != null) {
                    Integer label = pornResult.getLabel();
                    Float rate = pornResult.getRate();
                    return rate;
                }
                imageResult.getOcrResult();
                imageResult.getIllegalResult();
            } else {
                logger.error("Failed to get image check result");
            }
        } catch (ClientException e) {
            logger.error("Failed to get image check result");
            throw new RuntimeException(e);
        }
        logger.error("Failed to get image check result");
        throw new RuntimeException("Failed to get image check result");
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getSecret() {
        return secret;
    }

    public void setSecret(String secret) {
        this.secret = secret;
    }

    public String getGreenUrlPrefix() {
        return greenUrlPrefix;
    }

    public void setGreenUrlPrefix(String greenUrlPrefix) {
        this.greenUrlPrefix = greenUrlPrefix;
    }
}


text:
title: Triangles with integral sides and an integral angle
localeTitle: مثلثات ذات جوانب متكاملة وزاوية متكاملة
---
## المشكلة 279: مثلثات ذات جوانب متكاملة وزاوية متكاملة

هذا هو كعب. [ساعد مجتمعنا على توسيعه](https://github.com/freecodecamp/guides/tree/master/src/pages/certifications/coding-interview-prep/project-euler/problem-279-triangles-with-integral-sides-and-an-integral-angle/index.md) .

[سيساعدك دليل النمط السريع هذا على ضمان قبول طلب السحب](https://github.com/freecodecamp/guides/blob/master/README.md) .


text:
package js

import (
	"errors"
	"fmt"
	"github.com/scritch007/ShareMinatorApiGenerator/types"
	"github.com/scritch007/go-tools"
	"os"
	"strings"
)

type JSGenerator struct {
	apiFile *os.File
}

func NewJSGenerator(config *types.Config) (*JSGenerator, error) {
	g := new(JSGenerator)
	cF, err := os.OpenFile("api/api.js", os.O_WRONLY|os.O_TRUNC|os.O_CREATE, os.ModePerm)

	if nil != err {
		return nil, err
	}

	g.apiFile = cF
	return g, nil
}

func (g *JSGenerator) generateObject(o *types.ObjectDefinition) error {
	return generateObject(g.apiFile, o.Name, o.Fields)
}

func generateObject(w *os.File, name string, fields *[]types.ObjectField) error {

	return nil
}

func getCommandName(commandName *string) (out string) {
	res := strings.Split(*commandName, ".")
	out = "Command"
	for _, s := range res {
		out += tools.Capitalize(s)
	}
	return tools.JsonToGolang(&out)
}

func (g *JSGenerator) generateCommand(o *types.ObjectDefinition) (err error) {
	cname := getCommandName(&o.Name)
	g.apiFile.WriteString(fmt.Sprintf("function send%s(", cname))
	//mandatoryInputs := make([]string, 0, len(*o.Input))
	//for _, input := range *o.Input{
	//	if nil == input.Optional || !*input.Optional{
	//		mandatoryInputs = mandatoryInputs[:len(mandatoryInputs) + 1]
	//		mandatoryInputs[len(mandatoryInputs) - 1] = input.Name
	//	}
	//}
	//g.apiFile.WriteString(strings.Join(mandatoryInputs, ", "))
	if nil != o.Input && 0 != len(*o.Input) {
		g.apiFile.WriteString("input, ")
	}
	g.apiFile.WriteString("config, onSuccess, onError, onPending){\n")
	if nil != o.Input && 0 != len(*o.Input) {
		g.apiFile.WriteString("\t//TODO check that all the mandatory inputs are there\n")
	} else {
		g.apiFile.WriteString("\tvar input = null;\n")
	}
	g.apiFile.WriteString(fmt.Sprintf("\tsendCommand(\"%s\", input, config, onSuccess, onError, onPending);\n", o.Name))
	g.apiFile.WriteString("}\n")
	return nil
}
func (g *JSGenerator) generateEnum(o *types.ObjectDefinition) error {

	g.apiFile.WriteString(fmt.Sprintf("/******************%s******************/\n", o.Name))
	g.apiFile.WriteString(fmt.Sprintf("var %s = function(){};\n", o.Name))
	isIota := false
	for i, enum := range *o.Values {
		var value = i
		fmt.Println("i = ", i, " ", enum.Name)
		if nil == enum.Value {

			if 0 == i {
				isIota = true
			} else {
				if !isIota {
					return errors.New("Value " + enum.Name + " has not value but should have")
				}
			}
		} else {
			if isIota {
				return errors.New("Value " + enum.Name + " has a value but shouldn't")
			}
		}
		g.apiFile.WriteString(fmt.Sprintf("%s.%s = %d;\n", o.Name, enum.Name, value))
	}
	g.apiFile.WriteString(fmt.Sprintf("/******************%s******************/\n", o.Name))
	return nil
}

func (g *JSGenerator) GenerateObjects(a *types.APIDefinitions) error {
	for _, o := range a.Objects {
		err := g.generateObject(&o)
		if nil != err {
			return err
		}

	}
	return nil
}
func (g *JSGenerator) GenerateCommands(a *types.APIDefinitions) error {
	for category, cmds := range a.Commands {
		fmt.Println(category)
		for _, o := range *cmds {
			err := g.generateCommand(&o)
			if nil != err {
				return err
			}
		}
	}
	return nil
}
func (g *JSGenerator) GenerateEnums(a *types.APIDefinitions) error {
	for _, o := range a.Enums {
		err := g.generateEnum(&o)
		if nil != err {
			return err
		}
	}
	return nil
}

func getRequestName(commandName *string) (out string) {
	res := strings.Split(*commandName, ".")
	out = "Request"
	for _, s := range res {
		out += tools.Capitalize(s)
	}
	return tools.JsonToGolang(&out)
}

func (g *JSGenerator) GenerateRequests(a *types.APIDefinitions) error {
	g.apiFile.WriteString("var RequestsUrl = function(){};\n")
	for _, o := range a.Requests {
		g.apiFile.WriteString("RequestsUrl." + getRequestName(&o.Name) + " = \"auths/" + o.Name + "\";\n")
	}
	return nil
}


text:
package org.omg.PortableServer;

/**
* org/omg/PortableServer/POA.java .
* Generated by the IDL-to-Java compiler (portable), version "3.2"
* from ../../../../src/share/classes/org/omg/PortableServer/poa.idl
* Friday, March 1, 2013 3:32:42 AM PST
*/

/**
	 * A POA object manages the implementation of a
	 * collection of objects. The POA supports a name space
	 * for the objects, which are identified by Object Ids.
	 * A POA also provides a name space for POAs. A POA is
	 * created as a child of an existing POA, which forms a
	 * hierarchy starting with the root POA. A POA object
	 * must not be exported to other processes, or
	 * externalized with ORB::object_to_string.
	 */
public interface POA extends POAOperations, org.omg.CORBA.Object, org.omg.CORBA.portable.IDLEntity
{
} // interface POA


text:
Usage

*Main Scene is Voice Controlled with Voice Feedback*

Voice Commands:

**"Place Anchor"**
* Re-position the anchor in the world, the placement object is moved with the user gaze

**"Lock Anchor"**
* position the anchor in the current location of the placement object


text:
namespace Dhcp
{
    public interface IDhcpServerPacketRawWritable : IDhcpServerPacketWritable, IDhcpServerPacketRaw
    {

        /// <summary>
        /// Attempts to increase or decrease the packet buffer at the <paramref name="index"/> by the <paramref name="adjustmentAmount"/>.
        /// </summary>
        /// <param name="index">The buffer index where the adjustment should be made.</param>
        /// <param name="adjustmentAmount">The amount to adjust the buffer by. Positive numbers increase the buffer, negative numbers shrink the buffer.</param>
        /// <returns>true if the adjustment was successful</returns>
        bool TryAdjustBuffer(int index, int adjustmentAmount);

    }
}


text:
require 'minitest/autorun'
require 'fakeredis'
require 'redis-model'

REDIS_TTL = 1.1
$redis = Redis.new

Time.zone = 'UTC'

class ActiveSupport::TestCase
  setup do
    $redis.flushdb
  end
end


text:
package vn.tale.rxmvvm_sample.ui.users;

import java.util.List;
import java.util.NoSuchElementException;

import rx.Observable;
import rx.Scheduler;
import rx.functions.Func1;
import vn.tale.rxmvvm.task.Result;
import vn.tale.rxmvvm.task.Task;
import vn.tale.rxmvvm_sample.model.User;
import vn.tale.rxmvvm_sample.model.UserModel;

/**
 * Created by Giang Nguyen at Tiki on 6/8/16.
 */
public class UsersViewModel implements UsersMVVM.ViewModel {
  private final Task task;
  public final Observable<List<User>> loadUsersSuccess;
  public final Observable<String> loadUsersError;

  public UsersViewModel(final UserModel userModel, Scheduler scheduler) {
    final Observable<List<User>> getUsers = userModel.getUsers().subscribeOn(scheduler);
    task = Task.Factory.fromObservable(getUsers);
    loadUsersSuccess = task.success()
        .map(new Func1<Result.Success, List<User>>() {
          @Override public List<User> call(Result.Success success) {
            return success.getData();
          }
        });

    loadUsersError = task.error()
        .map(new Func1<Result.Error, String>() {
          @Override public String call(Result.Error error) {
            if (error.getThrowable() instanceof NoSuchElementException) {
              return "No Data";
            }
            return "Error occurred";
          }
        });
  }

  @Override public Observable<Void> loadingUsers() {
    return task.loading();
  }

  @Override
  public Observable<List<User>> loadUsersSuccess() {
    return loadUsersSuccess;
  }

  @Override
  public Observable<String> loadUsersError() {
    return loadUsersError;
  }

  @Override public void loadUsers() {
    task.start();
  }
}


text:
package org.apache.tinkerpop.gremlin.process.traversal.dsl;

import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.apache.tinkerpop.gremlin.process.traversal.P;

/**
 * @author Stephen Mallette (http://stephen.genoprime.com)
 */
@GremlinDsl
public interface SocialTraversalDsl<S, E> extends GraphTraversal.Admin<S, E> {
    public default GraphTraversal<S, Vertex> knows(final String personName) {
        return ((SocialTraversalDsl) out("knows")).person().has("name", personName);
    }

    public default <E2 extends Number> GraphTraversal<S, E2> meanAgeOfFriends() {
        return ((SocialTraversalDsl) out("knows")).person().values("age").mean();
    }

    @GremlinDsl.AnonymousMethod(returnTypeParameters = {"A", "A"}, methodTypeParameters = {"A"})
    public default GraphTraversal<S, E> person() {
        return hasLabel("person");
    }

    @GremlinDsl.AnonymousMethod(returnTypeParameters = {"A", "org.apache.tinkerpop.gremlin.structure.Vertex"}, methodTypeParameters = {"A"})
    public default GraphTraversal<S, Vertex> knowsOverride(final String personName) {
        return out("knows").hasLabel("person").has("name", personName);
    }

    @GremlinDsl.AnonymousMethod(returnTypeParameters = {"A", "E2"}, methodTypeParameters = {"A", "E2 extends java.lang.Number"})
    public default <E2 extends Number> GraphTraversal<S, E2> meanAgeOfFriendsOverride() {
        return out("knows").hasLabel("person").values("age").mean();
    }
}


text:
// Copyright (c) The Perspex Project. All rights reserved.
// Licensed under the MIT license. See licence.md file in the project root for full license information.

using Perspex.Controls;
using Perspex.Media;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Xunit;

#if PERSPEX_CAIRO
namespace Perspex.Cairo.RenderTests.Media
#elif PERSPEX_SKIA
namespace Perspex.Skia.RenderTests
#else
namespace Perspex.Direct2D1.RenderTests.Media
#endif
{
    public class LinearGradientBrushTests : TestBase
    {
        public LinearGradientBrushTests() : base(@"Media\LinearGradientBrush")
        {
        }

#if PERSPEX_SKIA
        [Fact(Skip = "FIXME")]
#else
        [Fact]
#endif
        public void LinearGradientBrush_RedBlue_Horizontal_Fill()
        {
            Decorator target = new Decorator
            {
                Padding = new Thickness(8),
                Width = 200,
                Height = 200,
                Child = new Border
                {
                    Background = new LinearGradientBrush
                    {
                        StartPoint = new RelativePoint(0, 0.5, RelativeUnit.Relative),
                        EndPoint = new RelativePoint(1, 0.5, RelativeUnit.Relative),
                        GradientStops =
                        {
                            new GradientStop { Color = Colors.Red, Offset = 0 },
                            new GradientStop { Color = Colors.Blue, Offset = 1 }
                        }
                    }
                }
            };

            RenderToFile(target);
            CompareImages();
        }

#if PERSPEX_SKIA
        [Fact(Skip = "FIXME")]
#else
        [Fact]
#endif
        public void LinearGradientBrush_RedBlue_Vertical_Fill()
        {
            Decorator target = new Decorator
            {
                Padding = new Thickness(8),
                Width = 200,
                Height = 200,
                Child = new Border
                {
                    Background = new LinearGradientBrush
                    {
                        StartPoint = new RelativePoint(0.5, 0, RelativeUnit.Relative),
                        EndPoint = new RelativePoint(0.5, 1, RelativeUnit.Relative),
                        GradientStops =
                        {
                            new GradientStop { Color = Colors.Red, Offset = 0 },
                            new GradientStop { Color = Colors.Blue, Offset = 1 }
                        }
                    }
                }
            };

            RenderToFile(target);
            CompareImages();
        }
    }
}


text:
import { useEffect } from '../uiApi';
import useHasMounted from './useHasMounted';

const useDidUpdate = (
  onDidUpdate,
  deps
) => {
  const _hasMounted = useHasMounted();
  /*eslint-disable react-hooks/exhaustive-deps */
  useEffect(() => {
    if (!_hasMounted) {
      onDidUpdate()
    }
  }, deps)
  // _hasMounted, onDidUpdate
  /*eslint-enable react-hooks/exhaustive-deps */
};

export default useDidUpdate


text:
package org.apache.flink.table.plan.rules.dataSet

import org.apache.calcite.plan.{Convention, RelOptRule, RelOptRuleCall, RelTraitSet}
import org.apache.calcite.rel.RelNode
import org.apache.calcite.rel.convert.ConverterRule
import org.apache.calcite.rel.logical.LogicalAggregate
import org.apache.flink.table.plan.nodes.dataset.{DataSetAggregate, DataSetConvention, DataSetUnion}
import scala.collection.JavaConversions._

class DataSetAggregateRule
  extends ConverterRule(
    classOf[LogicalAggregate],
    Convention.NONE,
    DataSetConvention.INSTANCE,
    "DataSetAggregateRule") {

  override def matches(call: RelOptRuleCall): Boolean = {
    val agg: LogicalAggregate = call.rel(0).asInstanceOf[LogicalAggregate]

    // for non-grouped agg sets we attach null row to source data
    // we need to apply DataSetAggregateWithNullValuesRule
    if (agg.getGroupSet.isEmpty) {
      return false
    }

    // distinct is translated into dedicated operator
    if (agg.getAggCallList.isEmpty &&
      agg.getGroupCount == agg.getRowType.getFieldCount &&
      agg.getRowType.equals(agg.getInput.getRowType) &&
      agg.getGroupSets.size() == 1) {
      return false
    }

    // check if we have distinct aggregates
    val distinctAggs = agg.getAggCallList.exists(_.isDistinct)

    !distinctAggs
  }

  override def convert(rel: RelNode): RelNode = {
    val agg: LogicalAggregate = rel.asInstanceOf[LogicalAggregate]
    val traitSet: RelTraitSet = rel.getTraitSet.replace(DataSetConvention.INSTANCE)
    val convInput: RelNode = RelOptRule.convert(agg.getInput, DataSetConvention.INSTANCE)

    if (agg.indicator) {
        agg.groupSets.map(set =>
          new DataSetAggregate(
            rel.getCluster,
            traitSet,
            convInput,
            agg.getNamedAggCalls,
            rel.getRowType,
            agg.getInput.getRowType,
            set.toArray,
            inGroupingSet = true
          ).asInstanceOf[RelNode]
        ).reduce(
          (rel1, rel2) => {
            new DataSetUnion(
              rel.getCluster,
              traitSet,
              rel1,
              rel2,
              rel.getRowType
            )
          }
        )
    } else {
      new DataSetAggregate(
        rel.getCluster,
        traitSet,
        convInput,
        agg.getNamedAggCalls,
        rel.getRowType,
        agg.getInput.getRowType,
        agg.getGroupSet.toArray,
        inGroupingSet = false
      )
    }
  }
}

object DataSetAggregateRule {
  val INSTANCE: RelOptRule = new DataSetAggregateRule
}


text:
class Contact < ActiveRecord::Base
  # t.integer :organization_id
  # t.string :name
  # t.string :email
  # t.string :telephone
  # t.string :address
  # t.string :zip
  # t.string :city
  # t.string :country
  # t.text :comment

  belongs_to :organization
  has_many :contact_relations

  attr_accessible :email, :name, :telephone, :address, :zip, :city, :country, :comment

  validates :name, presence: true
  validates :email, presence: true, uniqueness: {scope: :organization_id}

  VALID_PARENT_TYPES = ['Customer', 'Supplier', 'Warehouse', 'ContactRelation', 'User']

  def user_parent?
    return true if contact_relations.where("parent_type = 'User'").count > 0
    false
  end

  # For ApplicationHelper#delete_button
  def can_delete?
    return false if ContactRelation.where('contact_id=?', id).count > 0
    true
  end

  def parent_name
    parent.name
  end
end


text:
from __future__ import print_function, division  # Python 2 compatibility if needed

# In[2]:

import numpy as np
import numpy.random as rn
import matplotlib.pyplot as plt  # to plot
import matplotlib as mpl

from scipy import optimize       # to compare

import seaborn as sns
sns.set(context="talk", style="darkgrid", palette="hls", font="sans-serif", font_scale=1.05)

FIGSIZE = (19, 8)  #: Figure size, in inches!
mpl.rcParams['figure.figsize'] = FIGSIZE

# ----
#
# ## Algorithm
#
# The following pseudocode presents the simulated annealing heuristic.
#
# - It starts from a state $s_0$ and continues to either a maximum of $k_{\max}$ steps or until a state with an energy of $e_{\min}$ or less is found.
# - In the process, the call $\mathrm{neighbour}(s)$ should generate a randomly chosen neighbour of a given state $s$.
# - The annealing schedule is defined by the call $\mathrm{temperature}(r)$, which should yield the temperature to use, given the fraction $r$ of the time budget that has been expended so far.

# > **Simulated Annealing**:
# >
# > - Let $s$ = $s_0$
# > - For $k = 0$ through $k_{\max}$ (exclusive):
# >    + $T := \mathrm{temperature}(k ∕ k_{\max})$
# >    + Pick a random neighbour, $s_{\mathrm{new}} := \mathrm{neighbour}(s)$
# >    + If $P(E(s), E(s_{\mathrm{new}}), T) \geq \mathrm{random}(0, 1)$:
# >       * $s := s_{\mathrm{new}}$
# > - Output: the final state $s$

# ----
#
# ## Basic but generic Python code

# Let us start with a very generic implementation:

# In[3]:

def annealing(random_start,
              cost_function,
              random_neighbour,
              acceptance,
              temperature,
              maxsteps=1000,
              debug=True):
    """ Optimize the black-box function 'cost_function' with the simulated annealing algorithm."""
    state = random_start()
    cost = cost_function(state)
    states, costs = [state], [cost]
    for step in range(maxsteps):
        fraction = step / float(maxsteps)
        T = temperature(fraction)
        new_state = random_neighbour(state, fraction)
        new_cost = cost_function(new_state)
        if debug: print("Step #{:>2}/{:>2} : T = {:>4.3g}, state = {:>4.3g}, cost = {:>4.3g}, new_state = {:>4.3g}, new_cost = {:>4.3g} ...".format(step, maxsteps, T, state, cost, new_state, new_cost))
        if acceptance_probability(cost, new_cost, T) > rn.random():
            state, cost = new_state, new_cost
            states.append(state)
            costs.append(cost)
            # print("  ==> Accept it!")
        # else:
        #    print("  ==> Reject it...")
    return state, cost_function(state), states, costs

# ----
#
# ## Basic example
#
# We will use this to find the global minimum of the function $x \mapsto x^2$ on $[-10, 10]$.

# In[4]:

interval = (-10, 10)

def f(x):
    """ Function to minimize."""
    return x ** 2

def clip(x):
    """ Force x to be in the interval."""
    a, b = interval
    return max(min(x, b), a)

# In[5]:

def random_start():
    """ Random point in the interval."""
    a, b = interval
    return a + (b - a) * rn.random_sample()

# In[6]:

def cost_function(x):
    """ Cost of x = f(x)."""
    return f(x)

# In[7]:

def random_neighbour(x, fraction=1):
    """Move a little bit x, from the left or the right."""
    amplitude = (max(interval) - min(interval)) * fraction / 10
    delta = (-amplitude/2.) + amplitude * rn.random_sample()
    return clip(x + delta)

# In[8]:

def acceptance_probability(cost, new_cost, temperature):
    if new_cost < cost:
        # print("    - Acceptance probabilty = 1 as new_cost = {} < cost = {}...".format(new_cost, cost))
        return 1
    else:
        p = np.exp(- (new_cost - cost) / temperature)
        # print("    - Acceptance probabilty = {:.3g}...".format(p))
        return p

# In[9]:

def temperature(fraction):
    """ Example of temperature dicreasing as the process goes on."""
    return max(0.01, min(1, 1 - fraction))

# Let's try!

# In[10]:

annealing(random_start, cost_function, random_neighbour, acceptance_probability, temperature, maxsteps=30, debug=True);

# Now with more steps:

# In[11]:

state, c, states, costs = annealing(random_start, cost_function, random_neighbour, acceptance_probability, temperature, maxsteps=1000, debug=False)

state
c

# ----
#
# ## Visualizing the steps

# In[12]:

def see_annealing(states, costs):
    plt.figure()
    plt.suptitle("Evolution of states and costs of the simulated annealing")
    plt.subplot(121)
    plt.plot(states, 'r')
    plt.title("States")
    plt.subplot(122)
    plt.plot(costs, 'b')
    plt.title("Costs")
    plt.show()

# In[13]:

see_annealing(states, costs)

# ----
#
# ## More visualizations

# In[14]:

def visualize_annealing(cost_function):
    state, c, states, costs = annealing(random_start, cost_function, random_neighbour, acceptance_probability, temperature, maxsteps=1000, debug=False)
    see_annealing(states, costs)
    return state, c

# In[15]:

visualize_annealing(lambda x: x**3)

# In[16]:

visualize_annealing(lambda x: x**2)

# In[17]:

visualize_annealing(np.abs)

# In[18]:

visualize_annealing(np.cos)

# In[19]:

visualize_annealing(lambda x: np.sin(x) + np.cos(x))

# In all these examples, the simulated annealing converges to a global minimum.
# It can be non-unique, but it is found.

# ----
# > That's it for today, folks!
#
# More notebooks can be found on [my GitHub page](https://GitHub.com/Naereen/notebooks).


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <!--
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You under the Apache License, Version 2.0
    (the "License"); you may not use this file except in compliance with
    the License.  You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
    -->
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.apache.gora</groupId>
        <artifactId>gora</artifactId>
        <version>0.2-SNAPSHOT</version>
    </parent>
    <artifactId>gora-hbase</artifactId>
    <packaging>jar</packaging>

    <name>Apache Gora :: Hbase</name>

    <build>
        <sourceDirectory>src/main/java</sourceDirectory>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>build-helper-maven-plugin</artifactId>
                <version>${build-helper-maven-plugin.version}</version>
                <executions>
                    <execution>
                        <phase>generate-sources</phase>
                        <goals>
                            <goal>add-source</goal>
                        </goals>
                        <configuration>
                            <sources>
                                <source>src/examples/java</source>
                            </sources>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!-- Gora Internal Dependencies -->
        <dependency>
            <groupId>org.apache.gora</groupId>
            <artifactId>gora-core</artifactId>
            <version>${project.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.gora</groupId>
            <artifactId>gora-core</artifactId>
            <version>${project.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>

        <!-- Hadoop Dependencies -->
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase</artifactId>
            <version>0.90.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase</artifactId>
	    <version>0.90.0</version>
            <classifier>tests</classifier>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>avro</artifactId>
        </dependency>

        <!-- Misc Dependencies -->
        <dependency>
            <groupId>org.jdom</groupId>
            <artifactId>jdom</artifactId>
        </dependency>

        <!-- Logging Dependencies -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
	     <exclusions>
	       <exclusion>
                <groupId>javax.jms</groupId>
	        <artifactId>jms</artifactId>
	      </exclusion>
            </exclusions>

        </dependency>

        <!-- Testing Dependencies -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-test</artifactId>
        </dependency>

    </dependencies>

</project>