text:
typedef union{
	double v;
	uint8_t dchar[4];
}dvalue;

extern void rom_read(uint8_t *res, uint8_t len, uint8_t start);
extern void rom_readPID(double *pidRoll, double *pidPitch);
extern void rom_writePID(uint8_t *pid);

#endif

redpajama_set_name: RedPajamaGithub


text:
SYNONYM

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

#### Published in
Naturalist 96 (1946)

#### Original name
Boletus rubinus W.G. Sm., 1868

### Remarks
null


text:
type $npm$minimatch$Options = {
  debug?: boolean,
  nobrace?: boolean,
  noglobstar?: boolean,
  dot?: boolean,
  noext?: boolean,
  nocase?: boolean,
  nonull?: boolean,
  matchBase?: boolean,
  nocomment?: boolean,
  nonegate?: boolean,
  flipNegate?: boolean,
  ...
};

declare module "minimatch" {
  declare class Minimatch {
    constructor(pattern: string, options?: $npm$minimatch$Options): Minimatch,
    set: Array<Array<string | RegExp>>,
    regexp: null | RegExp, // null until .makeRe() is called
    negate: boolean,
    comment: boolean,
    empty: boolean,
    makeRe(): RegExp | false,
    match(name: string): boolean,
    matchOne(
      fileArray: Array<string>,
      patternArray: Array<string>,
      partial?: boolean
    ): boolean
  }

  declare class MinimatchModule {
    Minimatch: Class<Minimatch>,

    (name: string, pattern: string, options?: $npm$minimatch$Options): boolean,

    filter(
      pattern: string,
      options?: $npm$minimatch$Options
    ): (value: string) => boolean,

    match(
      list: Array<string>,
      pattern: string,
      options?: $npm$minimatch$Options
    ): Array<string>
  }

  declare module.exports: MinimatchModule;
}


text:
package com.umaqsud.regxlar.random;

import java.util.Random;

/**
 *
 * @author Umar Maqsud (umar.maqsud@campus.tu-berlin.de)
 *
 */
public class SeedRandomGenerator implements RandomGenerator {

    private Random random;

    public SeedRandomGenerator(double seed) {
        random = new Random(("" + seed).hashCode());
    }

    @Override
    public Double nextDouble() {
        return random.nextDouble();
    }

    @Override
    public Integer nextInt(int n) {
        return random.nextInt(n);
    }

    @Override
    public Integer nextInt() {
        return random.nextInt();
    }

}


text:
dojo.provide("dojox.cometd.ack");
dojo.require("dojox.cometd._base");

/*
 * This file provides the dojox cometd ack extension which
 * acknowledges the messages received in /meta/connect responses.
 * Each meta/connect is sent with the id of the last successful meta/connect
 * received.  The server uses this information to manage a queue of unacknowleged
 * messages.
 *
 * To use, add dojo.require("dojox.cometd.ack"); and if the handshake will be sent
 * with ext:{ack:true}.  If the server supports the same extension, then the
 * mechanism will be initialized.  The dojox.cometd.ackEnabled field may also be
 * used to optionally enable/disable the extension before init of cometd.
 *
 */
dojox.cometd._ack = new function(){
	var supportAcks = false;
	var lastAck = -1;

	this._in = function(msg){
		if (msg.channel == "/meta/handshake") {
			supportAcks = msg.ext && msg.ext.ack;
		} else if (supportAcks && msg.channel == "/meta/connect" && msg.ext && msg.ext.ack && msg.successful) {
			var ackId = parseInt(msg.ext.ack);
			lastAck = ackId;
		}
		return msg;
	}

	this._out = function(msg){

		if (msg.channel == "/meta/handshake") {
			if (!msg.ext)
				msg.ext = {};
			msg.ext.ack = dojox.cometd.ackEnabled;
			lastAck = -1;
		}
		if (supportAcks && msg.channel == "/meta/connect") {
			if (!msg.ext)
				msg.ext = {};
			msg.ext.ack = lastAck;
		}
		return msg;
	}
};

dojox.cometd._extendInList.push(dojo.hitch(dojox.cometd._ack, "_in"));
dojox.cometd._extendOutList.push(dojo.hitch(dojox.cometd._ack, "_out"));
dojox.cometd.ackEnabled = true;


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Ber. schweiz. bot. Ges. 73: 474 (1963)

#### Original name
Physcia hispidula subsp. hispidula

### Remarks
null


text:
package io.reflectoring.jiraalerts.common;

import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;

import java.util.List;

import org.apache.wicket.core.util.string.ComponentRenderer;
import org.apache.wicket.feedback.FencedFeedbackPanel;
import org.apache.wicket.markup.Markup;
import org.apache.wicket.markup.html.form.ChoiceRenderer;
import org.apache.wicket.markup.html.form.DropDownChoice;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.form.SimpleFormComponentLabel;
import org.apache.wicket.model.Model;
import org.apache.wicket.model.util.ListModel;
import org.apache.wicket.util.tester.FormTester;
import org.apache.wicket.util.tester.WicketTester;
import org.junit.Test;

import io.reflectoring.jiraalerts.application.testsetup.TestApplication;

public class FormControlDropDownPanelTest {

	private static final String TEST_STRING = "Test1";
	private static final String TEST_LABEL = "Label";
	private static final List<String> TEST_CHOICES = asList("Test0", TEST_STRING, "Test2");
	private static final String FORM_TEST_MARKUP = "<form wicket:id=\"form\">

</form>";

	private WicketTester wicketTester = new WicketTester(new TestApplication(this));
	private FormControlDropDownPanel<String> testSubject;

	@Test
	public void rendersSuccessful() throws Exception {
		String testString = "";
		testSubject = new FormControlDropDownPanel<String>("panel", Model.of(testString), new ListModel<>(TEST_CHOICES), new ChoiceRenderer<>(),
		        Model.of(TEST_LABEL));
		wicketTester.startComponentInPage(testSubject);

		wicketTester.assertComponent("panel:input", DropDownChoice.class);
		wicketTester.assertComponent("panel:label", SimpleFormComponentLabel.class);
		wicketTester.assertComponent("panel:feedback", FencedFeedbackPanel.class);
	}

	@Test
	public void formSubmitSetsDropDownValueInModel() throws Exception {
		startWithForm(false);

		FormTester formTester = wicketTester.newFormTester("form");
		formTester.select("panel:input", 1);
		formTester.submit();

		Object textFieldModelValue = wicketTester.getComponentFromLastRenderedPage("form:panel:input").getDefaultModelObject();
		assertThat(textFieldModelValue).isEqualTo(TEST_STRING);
	}

	@Test
	public void labelModelIsSetToLabel() throws Exception {
		String testString = "";
		wicketTester.startComponentInPage(new FormControlDropDownPanel<>("panel", Model.of(testString), new ListModel<>(TEST_CHOICES),
		        new ChoiceRenderer<>(), Model.of(TEST_LABEL)));

		wicketTester.assertModelValue("panel:label", TEST_LABEL);
	}

	@Test
	public void labelModelIsSetToPlaceholderAttribute() throws Exception {
		String testString = "";
		String panelMarkup = ComponentRenderer.renderComponent(new FormControlDropDownPanel<>("panel", Model.of(testString),
		        new ListModel<>(TEST_CHOICES), new ChoiceRenderer<>(), Model.of(TEST_LABEL))).toString();

		assertThat(panelMarkup).contains("placeholder=\"" + TEST_LABEL + "\"");
	}

	@Test
	public void textFieldIsRequiredWhenParameterIsTrue() throws Exception {
		startWithForm(true);

		FormTester formTester = wicketTester.newFormTester("form");
		formTester.submit();

		wicketTester.assertErrorMessages("input.Required");
	}

	@Test
	public void textFieldIsNotRequiredWhenParameterIsFalse() throws Exception {
		startWithForm(false);

		FormTester formTester = wicketTester.newFormTester("form");
		formTester.submit();

		wicketTester.assertNoErrorMessage();
	}

	private void startWithForm(boolean dropDownRequired) {
		String testString = "";
		Form<String> testForm = new Form<>("form");
		testForm.add(new FormControlDropDownPanel<>("panel", Model.of(testString), new ListModel<>(TEST_CHOICES), new ChoiceRenderer<>(),
		        Model.of(TEST_LABEL), dropDownRequired));
		wicketTester.startComponentInPage(testForm, Markup.of(FORM_TEST_MARKUP));
	}

	@Test
	public void getInputReturnsInputTextField() throws Exception {
		String testString = "";
		testSubject = new FormControlDropDownPanel<>("panel", Model.of(testString), new ListModel<>(TEST_CHOICES), new ChoiceRenderer<>(),
		        Model.of(TEST_LABEL));
		wicketTester.startComponentInPage(testSubject);

		assertThat(testSubject.getInput().getPath()).isEqualTo("0:panel:input");
	}
}


text:
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
/**
 *
 * Get the current page source.
 *
 * @returns {String} The current page source.
 *
 * @see  https://w3c.github.io/webdriver/webdriver-spec.html#dfn-get-page-source
 * @type protocol
 *
 */

var source = function source() {
  return this.requestHandler.create('/session/:sessionId/source');
};

exports.default = source;
module.exports = exports['default'];


text:
@title
The Hero Editor

@intro
Build a simple hero editor.

@description

## Setup to develop locally
Follow the [setup](guide/setup) instructions for creating a new project
named angular-tour-of-heroes.

The file structure should look like this:

    angular-tour-of-heroes

      src

        app

          app.component.ts

          app.module.ts

        main.ts

        index.html

        styles.css

        systemjs.config.js

        tsconfig.json

      node_modules ...

      package.json

When you're done with this page, the app should look like this <live-example></live-example>.

{@a keep-transpiling}

## Keep the app transpiling and running
Enter the following command in the terminal window:

  npm start

This command runs the TypeScript compiler in "watch mode", recompiling automatically when the code changes.
The command simultaneously launches the app in a browser and refreshes the browser when the code changes.

You can keep building the Tour of Heroes without pausing to recompile or refresh the browser.

## Show the hero
Add two properties to the `AppComponent`: a `title` property for the app name and a `hero` property
for a hero named "Windstorm."

Now update the template in the `@Component` decorator with data bindings to these new properties.

The browser refreshes and displays the title and hero name.

The double curly braces are Angular's *interpolation binding* syntax.
These interpolation bindings present the component's `title` and `hero` property values,
as strings, inside the HTML header tags.

Read more about interpolation in the [Displaying Data](guide/displaying-data) page.

### Hero object

The hero needs more properties.
Convert the `hero` from a literal string to a class.

Create a `Hero` class with `id` and `name` properties.
Add these properties near the top of the `app.component.ts` file, just below the import statement.

In the `AppComponent` class, refactor the component's `hero` property to be of type `Hero`,
then initialize it with an `id` of `1` and the name `Windstorm`.

Because you changed the hero from a string to an object,
update the binding in the template to refer to the hero's `name` property.

The browser refreshes and continues to display the hero's name.

### Adding HTML with multi-line template strings

To show all of the hero's properties,
add a `<div>` for the hero's `id` property and another `<div>` for the hero's `name`.
To keep the template readable, place each `<div>` on its own line.

The backticks around the component template let you put the `<h1>`, `<h2>`, and `<div>` elements on their own lines,
thanks to the template literals feature in ES2015 and TypeScript. For more information, see
Template literals.

## Edit the hero name

Users should be able to edit the hero name in an `<input>` textbox.
The textbox should both _display_ the hero's `name` property
and _update_ that property as the user types.

You need a two-way binding between the `<input>` form element and the `hero.name` property.

### Two-way binding

Refactor the hero name in the template so it looks like this:

`[(ngModel)]` is the Angular syntax to bind the `hero.name` property
to the textbox.
Data flows _in both directions:_ from the property to the textbox,
and from the textbox back to the property.

Unfortunately, immediately after this change, the application breaks.
If you looked in the browser console, you'd see Angular complaining that
"`ngModel` ... isn't a known property of `input`."

Although `NgModel` is a valid Angular directive, it isn't available by default.
It belongs to the optional `FormsModule`.
You must opt-in to using that module.

### Import the _FormsModule_

Open the `app.module.ts` file and import the `FormsModule` symbol from the `@angular/forms` library.
Then add the `FormsModule` to the `@NgModule` metadata's `imports` array, which contains the list
of external modules that the app uses.

The updated `AppModule` looks like this:

Read more about `FormsModule` and `ngModel` in the
[Two-way data binding with ngModel](guide/forms#ngModel) section of the
[Forms](guide/forms) guide and the
[Two-way binding with NgModel](guide/template-syntax#ngModel) section of the
[Template Syntax](guide/template-syntax) guide.

When the browser refreshes, the app should work again.
You can edit the hero's name and see the changes reflected immediately in the `<h2>` above the textbox.

## The road you've travelled

Take stock of what you've built.

* The Tour of Heroes app uses the double curly braces of interpolation (a type of one-way data binding)
to display the app title and properties of a `Hero` object.
* You wrote a multi-line template using ES2015's template literals to make the template readable.
* You added a two-way data binding to the `<input>` element
using the built-in `ngModel` directive. This binding both displays the hero's name and allows users to change it.
* The `ngModel` directive propagates changes to every other binding of the `hero.name`.

Your app should look like this <live-example></live-example>.

Here's the complete `app.component.ts` as it stands now:

## The road ahead
In the [next tutorial page](tutorial/toh-pt2), you'll build on the Tour of Heroes app to display a list of heroes.
You'll also allow the user to select heroes and display their details.
You'll learn more about how to retrieve lists and bind them to the template.


text:
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Data.EntityModel.Emitters;
using System.Data.Metadata.Edm;
using System.Data.Services.Design;
using System.Diagnostics;
using System.IO;
using System.Linq;

namespace System.Data.Metadata.Edm
{
    internal static partial class Helper
    {
        internal static bool IsCollectionType(GlobalItem item)
        {
            return (BuiltInTypeKind.CollectionType == item.BuiltInTypeKind);
        }
        internal static bool IsComplexType(EdmType type)
        {
            return (BuiltInTypeKind.ComplexType == type.BuiltInTypeKind);
        }
        internal static bool IsEntitySet(EntitySetBase entitySetBase)
        {
            return BuiltInTypeKind.EntitySet == entitySetBase.BuiltInTypeKind;
        }
        internal static bool IsPrimitiveType(EdmType type)
        {
            return (BuiltInTypeKind.PrimitiveType == type.BuiltInTypeKind);
        }
    }

    internal static class TypeSemantics
    {
        internal static bool IsComplexType(TypeUsage type)
        {
            return Helper.IsComplexType(type.EdmType);
        }
    }

    internal static class EdmProviderManifest
    {
        // System Facet Info
        /// <summary>
        /// Name of the MaxLength Facet
        /// </summary>
        internal const string MaxLengthFacetName = "MaxLength";

        /// <summary>
        /// Name of the Unicode Facet
        /// </summary>
        internal const string UnicodeFacetName = "Unicode";

        /// <summary>
        /// Name of the FixedLength Facet
        /// </summary>
        internal const string FixedLengthFacetName = "FixedLength";

        /// <summary>
        /// Name of the DateTimeKind Facet
        /// </summary>
        internal const string DateTimeKindFacetName = "DateTimeKind";

        /// <summary>
        /// Name of the PreserveSeconds Facet
        /// </summary>
        internal const string PreserveSecondsFacetName = "PreserveSeconds";

        /// <summary>
        /// Name of the Precision Facet
        /// </summary>
        internal const string PrecisionFacetName = "Precision";

        /// <summary>
        /// Name of the Scale Facet
        /// </summary>
        internal const string ScaleFacetName = "Scale";

        /// <summary>
        /// Name of the Nullable Facet
        /// </summary>
        internal const string NullableFacetName = "Nullable";

        /// <summary>
        /// Name of the DefaultValue Facet
        /// </summary>
        internal const string DefaultValueFacetName = "DefaultValue";

        ///// <summary>
        ///// Name of the DefaultType metadata property
        ///// </summary>
        //internal const string DefaultTypeMetadataPropertyName = "DefaultType";

        /// <summary>
        /// Name of the Collation Facet
        /// </summary>
        internal const string CollationFacetName = "Collation";
    }

    internal static class TypeSystem
    {
        private static readonly System.Reflection.MethodInfo s_getDefaultMethod = typeof(TypeSystem).GetMethod("GetDefault", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
        private static T GetDefault<T>() { return default(T); }

        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining | System.Runtime.CompilerServices.MethodImplOptions.NoOptimization)]
        internal static object GetDefaultValue(Type type)
        {
            // null is always the default for non value types and Nullable<>
            if (!type.IsValueType ||
                (type.IsGenericType &&
                 typeof(Nullable<>) == type.GetGenericTypeDefinition()))
            {
                return null;
            }
            System.Reflection.MethodInfo getDefaultMethod = s_getDefaultMethod.MakeGenericMethod(type);
            object defaultValue = getDefaultMethod.Invoke(null, new object[] { });
            return defaultValue;
        }
    }

    internal static class Schema
    {
        public const string CodeGenerationSchemaNamespace = "http://schemas.microsoft.com/ado/2006/04/codegeneration";
    }
}

namespace System.Data.EntityModel
{
    /// <summary>
    /// Summary description for ClientApiGenerator.
    /// </summary>
    internal sealed class ClientApiGenerator : IDisposable
    {
        #region Instance Fields
        private CodeCompileUnit _compileUnit;
        private bool _isLanguageCaseSensitive = true;

        private EdmItemCollection _edmItemCollection;
        private FixUpCollection _fixUps;
        private AttributeEmitter _attributeEmitter;
        private EntityClassGenerator _generator;
        private List<EdmSchemaError> _errors;
        private TypeReference _typeReference = new TypeReference();
        private string _sourceEdmNamespaceName;
        private string _defaultContainerNamespace;
        private string _namespacePrefix;
        private Dictionary<string, string> _namespaceMap;
        private EventHandler<TypeGeneratedEventArgs> _onTypeGenerated;
        private EventHandler<PropertyGeneratedEventArgs> _onPropertyGenerated;
        #endregion

        #region Public Methods
        public ClientApiGenerator(object sourceSchema, EdmItemCollection edmItemCollection, EntityClassGenerator generator, List<EdmSchemaError> errors, string namespacePrefix)
        {
            Debug.Assert(edmItemCollection != null, "edmItemCollection is null");
            Debug.Assert(generator != null, "generator is null");
            Debug.Assert(errors != null, "errors is null");

            _edmItemCollection = edmItemCollection;
            _generator = generator;
            _errors = errors;
            _attributeEmitter = new AttributeEmitter(_typeReference);
            _namespacePrefix = namespacePrefix;

            // generate map for inherited types and prefixed types
            _namespaceMap = new Dictionary<string, string>();

            _onTypeGenerated = new EventHandler<TypeGeneratedEventArgs>(TypeGeneratedEventHandler);
            _onPropertyGenerated = new EventHandler<PropertyGeneratedEventArgs>(PropertyGeneratedEventHandler);

            //// This constructor can be called multiple times with the same EntityClassGenerator. That is, many instances
            //// of the ClientApiGenerator can add handlers to one instance of the EntityClassGenerator.
            //// Make sure the handlers are not left on the EntityClassGenerator after the ClientApiGenerator is no longer in use.
            //// See the Dispose method

            _generator.OnTypeGenerated += _onTypeGenerated;
            _generator.OnPropertyGenerated += _onPropertyGenerated;
        }

        public void Dispose()
        {
            //// Make sure the handlers are not left on the EntityClassGenerator after the ClientApiGenerator is no longer in use.

            _generator.OnTypeGenerated -= _onTypeGenerated;
            _generator.OnPropertyGenerated -= _onPropertyGenerated;
        }

        internal EdmItemCollection EdmItemCollection
        {
            get { return this._edmItemCollection; }
        }

        public string NamespacePrefix
        {
            get { return this._namespacePrefix; }
        }

        public Dictionary<string, string> NamespaceMap
        {
            get { return this._namespaceMap; }
        }

        /// <summary>
        /// Does code generation emits collections inherited from DataServiceCollection
        /// </summary>
        internal bool UseDataServiceCollection
        {
            get { return _generator.UseDataServiceCollection; }
        }

        /// <summary>Version for which to generate code.</summary>
        internal DataServiceCodeVersion Version
        {
            get { return _generator.Version; }
        }

        /// <summary>
        /// Parses a source Schema and outputs client-side generated code to
        /// the output TextWriter.
        /// </summary>
        /// <param name="schema">The source Schema</param>
        /// <param name="output">The TextWriter in which to write the output</param>
        /// <param name="outputUri">The Uri for the output. Can be null.</param>
        /// <returns>A list of GeneratorErrors.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification="Reviewed")]
        internal void GenerateCode(LazyTextWriterCreator target)
        {
            Debug.Assert(target != null, "target parameter is null");

            IndentedTextWriter indentedTextWriter = null;
            System.IO.Stream tempFileStream = null;
            System.IO.StreamReader reader = null;
            System.IO.StreamWriter writer = null;
            TempFileCollection tempFiles = null;
            try
            {
                CodeDomProvider provider = null;
                switch (Language)
                {
                    case LanguageOption.GenerateCSharpCode:
                        provider = new Microsoft.CSharp.CSharpCodeProvider();
                        break;

                    case LanguageOption.GenerateVBCode:
                        provider = new Microsoft.VisualBasic.VBCodeProvider();
                        break;
                }

                _isLanguageCaseSensitive = (provider.LanguageOptions & LanguageOptions.CaseInsensitive) == 0;

                new NamespaceEmitter(this, this.NamespacePrefix, target.TargetFilePath).Emit();

                // if there were errors we don't need the output file
                if (RealErrorsExist)
                {
                    return;
                }

                if (FixUps.Count == 0 || !FixUpCollection.IsLanguageSupported(Language))
                {
                    indentedTextWriter = new IndentedTextWriter(target.GetOrCreateTextWriter(), "\t");
                }
                else
                {
                    // need to write to a temporary file so we can do fixups...
                    tempFiles = new TempFileCollection(Path.GetTempPath());
                    string filename = Path.Combine(tempFiles.TempDir, "EdmCodeGenFixup-" + Guid.NewGuid().ToString() + ".tmp");
                    tempFiles.AddFile(filename, false);
                    tempFileStream = new System.IO.FileStream(filename, System.IO.FileMode.CreateNew, System.IO.FileAccess.ReadWrite,
                        System.IO.FileShare.None);
                    indentedTextWriter = new IndentedTextWriter(new System.IO.StreamWriter(tempFileStream), "\t");
                }

                CodeGeneratorOptions styleOptions = new CodeGeneratorOptions();
                styleOptions.BracingStyle = "C";
                styleOptions.BlankLinesBetweenMembers = false;
                styleOptions.VerbatimOrder = true;
                provider.GenerateCodeFromCompileUnit(CompileUnit, indentedTextWriter, styleOptions);

                // if we wrote to a temp file need to post process the file...
                if (tempFileStream != null)
                {
                    indentedTextWriter.Flush();
                    tempFileStream.Seek(0, System.IO.SeekOrigin.Begin);
                    reader = new System.IO.StreamReader(tempFileStream);
                    FixUps.Do(reader, target.GetOrCreateTextWriter(), Language, !String.IsNullOrEmpty(SourceObjectNamespaceName));
                }
            }
            catch (System.UnauthorizedAccessException ex)
            {
                AddError(ModelBuilderErrorCode.SecurityError, EdmSchemaErrorSeverity.Error, ex);
            }
            catch (System.IO.FileNotFoundException ex)
            {
                AddError(ModelBuilderErrorCode.FileNotFound, EdmSchemaErrorSeverity.Error, ex);
            }
            catch (System.Security.SecurityException ex)
            {
                AddError(ModelBuilderErrorCode.SecurityError, EdmSchemaErrorSeverity.Error, ex);
            }
            catch (System.IO.DirectoryNotFoundException ex)
            {
                AddError(ModelBuilderErrorCode.DirectoryNotFound, EdmSchemaErrorSeverity.Error, ex);
            }
            catch (System.IO.IOException ex)
            {
                AddError(ModelBuilderErrorCode.IOException, EdmSchemaErrorSeverity.Error, ex);
            }
            finally
            {
                if (indentedTextWriter != null)
                {
                    indentedTextWriter.Close();
                }
                if (tempFileStream != null)
                {
                    tempFileStream.Close();
                }
                if (tempFiles != null)
                {
                    tempFiles.Delete();
                    ((IDisposable)tempFiles).Dispose();
                }
                if (reader != null)
                {
                    reader.Close();
                }
                if (writer != null)
                {
                    writer.Close();
                }
            }
        }

        /// <summary>
        /// Verification code invoked for types
        /// </summary>
        /// <param name="item">The type being generated</param>
        internal void VerifyLanguageCaseSensitiveCompatibilityForType(GlobalItem item)
        {
            if (_isLanguageCaseSensitive)
            {
                return; // no validation necessary
            }

            try
            {
                _edmItemCollection.GetItem<GlobalItem>(
                                                        Identity(item),
                                                        true   // ignore case
                                                    );
            }
            catch (InvalidOperationException ex)
            {
                AddError(ModelBuilderErrorCode.IncompatibleSettingForCaseSensitiveOption, EdmSchemaErrorSeverity.Error, ex);
            }
        }

        /// <summary>
        /// Verification code invoked for properties
        /// </summary>
        /// <param name="item">The property or navigation property being generated</param>
        internal void VerifyLanguageCaseSensitiveCompatibilityForProperty(EdmMember item)
        {
            if (_isLanguageCaseSensitive)
            {
                return; // no validation necessary
            }

            Debug.Assert(item != null);

            ReadOnlyMetadataCollection<EdmMember> members = item.DeclaringType.Members;
            HashSet<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            foreach (EdmMember member in members)
            {
                if (set.Contains(Identity(member)) &&
                    String.Equals(Identity(item), Identity(member), StringComparison.OrdinalIgnoreCase))
                {
                    AddError(ModelBuilderErrorCode.IncompatibleSettingForCaseSensitiveOption, EdmSchemaErrorSeverity.Error,
                                new InvalidOperationException(Strings.PropertyExistsWithDifferentCase(Identity(item))));
                }
                else
                {
                    set.Add(Identity(member));
                }
            }
        }

        /// <summary>
        /// Verification code invoked for entity sets
        /// </summary>
        /// <param name="item">The entity container being generated</param>
        internal void VerifyLanguageCaseSensitiveCompatibilityForEntitySet(System.Data.Metadata.Edm.EntityContainer item)
        {
            if (_isLanguageCaseSensitive)
            {
                return; // no validation necessary
            }

            Debug.Assert(item != null);

            HashSet<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            foreach (EntitySetBase entitySetBase in item.BaseEntitySets)
            {
                if (Helper.IsEntitySet(entitySetBase))
                {
                    EntitySet entitySet = (EntitySet)entitySetBase;
                    if (set.Contains(Identity(entitySet)))
                    {
                        AddError(ModelBuilderErrorCode.IncompatibleSettingForCaseSensitiveOption, EdmSchemaErrorSeverity.Error,
                                    new InvalidOperationException(Strings.EntitySetExistsWithDifferentCase(Identity(entitySet))));
                    }
                    else
                    {
                        set.Add(Identity(entitySet));
                    }
                }
            }
        }

        #endregion

        #region Internal Properties

        internal LanguageOption Language
        {
            get
            {
                return _generator.LanguageOption;
            }
        }

        internal TypeReference TypeReference
        {
            get { return _typeReference; }
        }

        internal CodeCompileUnit CompileUnit
        {
            get
            {
                if (_compileUnit == null)
                    _compileUnit = new CodeCompileUnit();

                return _compileUnit;
            }
        }

        public void AddError(string message, ModelBuilderErrorCode errorCode, EdmSchemaErrorSeverity severity)
        {
        }

        public void AddError(ModelBuilderErrorCode errorCode, EdmSchemaErrorSeverity severity, Exception ex)
        {
        }

        internal void AddError(string message, ModelBuilderErrorCode errorCode, EdmSchemaErrorSeverity severity, Exception ex)
        {
        }

        /// <summary>
        /// Check collection for any real errors (Severity != Warning)
        /// </summary>
        public bool RealErrorsExist
        {
            get
            {
                foreach (EdmSchemaError error in _errors)
                {
                    if (error.Severity != EdmSchemaErrorSeverity.Warning)
                        return true;
                }
                return false;
            }
        }

        public IEnumerable<GlobalItem> GetSourceTypes()
        {
            foreach (EntityContainer container in _edmItemCollection.GetItems<EntityContainer>())
            {
                BuiltInTypeKind kind = container.BuiltInTypeKind;
                yield return container;
            }

            foreach (EdmType item in _edmItemCollection.GetItems<EdmType>())
            {
                switch (item.BuiltInTypeKind)
                {
                    case BuiltInTypeKind.AssociationType:
                    case BuiltInTypeKind.ComplexType:
                    case BuiltInTypeKind.EntityType:
                        yield return item;
                        break;
                    case BuiltInTypeKind.EdmFunction:
                    case BuiltInTypeKind.PrimitiveType:
                        break;
                    default:
                        Debug.Assert(false, item.BuiltInTypeKind.ToString());
                        break;
                }
            }
        }

        public string GetClientTypeNamespace(string serviceTypeNamespace)
        {
            if (string.IsNullOrEmpty(this.NamespacePrefix)) return serviceTypeNamespace;

            if (string.IsNullOrEmpty(serviceTypeNamespace) ||
                ((this.DefaultContainerNamespace != null) && (this.DefaultContainerNamespace == serviceTypeNamespace)))
            {
                return this.NamespacePrefix;
            }
            else
            {
                return this.NamespacePrefix + "." + serviceTypeNamespace;
            }
        }

        public string GetContainerNamespace(EntityContainer container)
        {
            if (container == null) return null;

            string namespaceName = null;
            EntitySetBase baseEntitySet = container.BaseEntitySets.FirstOrDefault();
            if (null != baseEntitySet)
            {
                namespaceName = baseEntitySet.ElementType.NamespaceName;
            }

            return namespaceName;
        }

        public CodeTypeReference GetLeastPossibleQualifiedTypeReference(EdmType type)
        {
            string typeRef;
            string clientNamespace = GetClientTypeNamespace(type.NamespaceName);
            if (clientNamespace == SourceEdmNamespaceName)
            {
                // we are already generating in this namespace, no need to qualify it
                typeRef = type.Name;
            }
            else
            {
                typeRef = GetObjectNamespace(clientNamespace) + "." + type.Name;
            }

            return TypeReference.FromString(typeRef);
        }

        public string SourceEdmNamespaceName
        {
            get
            {
                if (null != _sourceEdmNamespaceName)
                {
                    return _sourceEdmNamespaceName;
                }

                //
                foreach (GlobalItem item in GetSourceTypes())
                {
                    EdmType edm = item as EdmType;
                    if (null != edm)
                    {
                        return edm.NamespaceName;
                    }
                }

                return null;
            }
            set
            {
                _sourceEdmNamespaceName = value;
            }
        }

        public string DefaultContainerNamespace
        {
            get { return _defaultContainerNamespace; }
            set { _defaultContainerNamespace = value; }
        }

        public string SourceObjectNamespaceName
        {
            get
            {
                string sourceEdmNamespaceName = SourceEdmNamespaceName;
                if (!String.IsNullOrEmpty(sourceEdmNamespaceName))
                {
                    return GetObjectNamespace(sourceEdmNamespaceName);
                }

                return null;
            }
        }

        private string GetObjectNamespace(string csdlNamespaceName)
        {
            Debug.Assert(csdlNamespaceName != null, "csdlNamespaceName is null");

            string objectNamespace;
            if (_generator.EdmToObjectNamespaceMap.TryGetObjectNamespace(csdlNamespaceName, out objectNamespace))
            {
                return objectNamespace;
            }

            return csdlNamespaceName;
        }

        /// <summary>
        ///
        /// </summary>
        /// <value></value>
        internal FixUpCollection FixUps
        {
            get
            {
                if (_fixUps == null)
                    _fixUps = new FixUpCollection();

                return _fixUps;
            }
        }

        internal AttributeEmitter AttributeEmitter
        {
            get { return _attributeEmitter; }
        }

        internal bool IsLanguageCaseSensitive
        {
            get { return _isLanguageCaseSensitive; }
        }

        internal StringComparison LanguageAppropriateStringComparer
        {
            get
            {
                if (IsLanguageCaseSensitive)
                {
                    return StringComparison.Ordinal;
                }
                else
                {
                    return StringComparison.OrdinalIgnoreCase;
                }
            }
        }

        /// <summary>
        /// Helper method that raises the TypeGenerated event
        /// </summary>
        /// <param name="eventArgs">The event arguments passed to the subscriber</param>
        internal void RaiseTypeGeneratedEvent(TypeGeneratedEventArgs eventArgs)
        {
            _generator.RaiseTypeGeneratedEvent(eventArgs);
        }

        /// <summary>
        /// Helper method that raises the PropertyGenerated event
        /// </summary>
        /// <param name="eventArgs">The event arguments passed to the subscriber</param>
        internal void RaisePropertyGeneratedEvent(PropertyGeneratedEventArgs eventArgs)
        {
            _generator.RaisePropertyGeneratedEvent(eventArgs);
        }

        /// <summary>
        /// Gets the collection type to be returned for a multi-valued navigation property.
        /// </summary>
        /// <returns>Type name which is decided based on UseDataServiceCollection setting.</returns>
        internal string GetRelationshipMultiplicityManyCollectionTypeName()
        {
            return this.UseDataServiceCollection ? "System.Data.Services.Client.DataServiceCollection" : "System.Collections.ObjectModel.Collection";
        }

        #endregion

        private static string Identity(EdmMember member)
        {
            return member.ToString();
        }
        private static string Identity(EntitySetBase entitySet)
        {
            return entitySet.ToString();
        }
        private static string Identity(MetadataItem item)
        {
            return item.ToString();
        }

        private void TypeGeneratedEventHandler(object sender, TypeGeneratedEventArgs eventArgs)
        {
            if (!this.UseDataServiceCollection)
            {
                return;
            }

            if (eventArgs.TypeSource.BuiltInTypeKind != BuiltInTypeKind.EntityType &&
                eventArgs.TypeSource.BuiltInTypeKind != BuiltInTypeKind.ComplexType)
            {
                return;
            }

            if (eventArgs.TypeSource.BuiltInTypeKind == BuiltInTypeKind.EntityType)
            {
                // Generate EntitySetAttribute only if there is exactly one entity set associated
                // with the entity type. The DataServiceEntitySetAttribute is not generated for ComplexType(s).
                EntitySetBase entitySet = this.GetUniqueEntitySetForType((EntityType)eventArgs.TypeSource);
                if (entitySet != null)
                {
                    List<CodeAttributeDeclaration> additionalAttributes = eventArgs.AdditionalAttributes;
                    CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(
                        new CodeTypeReference(typeof(System.Data.Services.Common.EntitySetAttribute),
                            CodeTypeReferenceOptions.GlobalReference), new CodeAttributeArgument(new CodePrimitiveExpression(entitySet.Name)));
                    additionalAttributes.Add(attribute);
                }
            }

            //// Determine if type being generated has a base type
            if (eventArgs.BaseType != null && !String.IsNullOrEmpty(eventArgs.BaseType.BaseType))
            {
                if (this.GetSourceTypes().Where(x => x.BuiltInTypeKind == BuiltInTypeKind.EntityType).Where(x => ((EntityType)x).Name == eventArgs.BaseType.BaseType).Count() != 0)
                {
                    //// Don't generate the PropertyChanged event and OnPropertyChanged method for derived type classes
                    return;
                }
            }

            //// Add the INotifyPropertyChanged interface

            List<Type> additionalInterfaces = eventArgs.AdditionalInterfaces;

            additionalInterfaces.Add(typeof(System.ComponentModel.INotifyPropertyChanged));

            //// Add the implementation of the INotifyPropertyChanged interface

            //// Generate this code:
            ////
            //// CSharp:
            ////
            //// public event global::System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
            ////
            //// protected virtual void OnPropertyChanged(string property) {
            ////     if ((this.PropertyChanged != null)) {
            ////         this.PropertyChanged(this, new global::System.ComponentModel.PropertyChangedEventArgs(property));
            ////     }
            //// }
            ////
            //// Visual Basic:
            ////
            //// Public Event PropertyChanged As Global.System.ComponentModel.PropertyChangedEventHandler Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged
            //// Protected Overridable Sub OnPropertyChanged(ByVal [property] As String)
            ////     If (Not (Me.PropertyChangedEvent) Is Nothing) Then
            ////         RaiseEvent PropertyChanged(Me, New Global.System.ComponentModel.PropertyChangedEventArgs([property]))
            ////     End If
            //// End Sub

            CodeMemberEvent propertyChangedEvent = new CodeMemberEvent();
            propertyChangedEvent.Type = new CodeTypeReference(typeof(System.ComponentModel.PropertyChangedEventHandler), CodeTypeReferenceOptions.GlobalReference);
            propertyChangedEvent.Name = "PropertyChanged";
            propertyChangedEvent.Attributes = MemberAttributes.Public;
            propertyChangedEvent.ImplementationTypes.Add(typeof(System.ComponentModel.INotifyPropertyChanged));

            AttributeEmitter.AddGeneratedCodeAttribute(propertyChangedEvent);

            eventArgs.AdditionalMembers.Add(propertyChangedEvent);

            CodeMemberMethod propertyChangedMethod = new CodeMemberMethod();
            propertyChangedMethod.Name = "OnPropertyChanged";
            propertyChangedMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(System.String), CodeTypeReferenceOptions.GlobalReference), "property"));
            propertyChangedMethod.ReturnType = new CodeTypeReference(typeof(void));

            AttributeEmitter.AddGeneratedCodeAttribute(propertyChangedMethod);

            propertyChangedMethod.Statements.Add(
                    new CodeConditionStatement(
                        new CodeBinaryOperatorExpression(
                            new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "PropertyChanged"),
                                CodeBinaryOperatorType.IdentityInequality,
                                new CodePrimitiveExpression(null)),
                            new CodeExpressionStatement(
                            new CodeDelegateInvokeExpression(
                                new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "PropertyChanged"),
                                    new CodeExpression[] {
                                    new CodeThisReferenceExpression(),
                                    new CodeObjectCreateExpression(new CodeTypeReference(typeof(System.ComponentModel.PropertyChangedEventArgs), CodeTypeReferenceOptions.GlobalReference), new CodeArgumentReferenceExpression("property"))
                                }))));
            propertyChangedMethod.Attributes = MemberAttributes.Family;
            eventArgs.AdditionalMembers.Add(propertyChangedMethod);
        }

        private void PropertyGeneratedEventHandler(object sender, PropertyGeneratedEventArgs eventArgs)
        {
            if (!this.UseDataServiceCollection)
            {
                return;
            }

            if (eventArgs.PropertySource.BuiltInTypeKind != BuiltInTypeKind.EdmProperty &&
                eventArgs.PropertySource.BuiltInTypeKind != BuiltInTypeKind.NavigationProperty)
            {
                return;
            }

            if (((EdmMember)eventArgs.PropertySource).DeclaringType.BuiltInTypeKind != BuiltInTypeKind.EntityType &&
                ((EdmMember)eventArgs.PropertySource).DeclaringType.BuiltInTypeKind != BuiltInTypeKind.ComplexType)
            {
                return;
            }

            string name = eventArgs.PropertySource.BuiltInTypeKind == BuiltInTypeKind.EdmProperty ? ((EdmProperty)eventArgs.PropertySource).Name : ((NavigationProperty)eventArgs.PropertySource).Name;

            // Add call to the OnPropertyChanged method
            eventArgs.AdditionalAfterSetStatements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(
                new CodeThisReferenceExpression(), "OnPropertyChanged",
                new CodeExpression[] { new CodePrimitiveExpression(name) }
                )));
        }

        /// <summary>Given an entity type, returns the corresponding entity set if it's unique.</summary>
        /// <param name="entityType">Given entity type.</param>
        /// <returns>Corresponding entity set if it's unique, null otherwise.</returns>
        private EntitySetBase GetUniqueEntitySetForType(EntityType entityType)
        {
            HashSet<EntitySetBase> entitySets = new HashSet<EntitySetBase>(EqualityComparerEntitySet.Default);

            foreach (EntityContainer container in this.EdmItemCollection.GetItems<EntityContainer>())
            {
                bool alreadyAdded = false;
                foreach (EntitySetBase es in container.BaseEntitySets
                                                      .Where(x => x.BuiltInTypeKind == BuiltInTypeKind.EntitySet &&
                                                                  x.ElementType == entityType))
                {
                    if (alreadyAdded == true)
                    {
                        return null;
                    }

                    alreadyAdded = true;
                    entitySets.Add(es);
                }
            }

            if (entitySets.Count == 1)
            {
                return entitySets.Single();
            }
            else
            {
                return null;
            }
        }

        /// <summary>Equality comparer used for deciding whether to add EntitySet attribute to an entity type.</summary>
        public class EqualityComparerEntitySet : IEqualityComparer<EntitySetBase>
        {
            /// <summary>Cached singleton comparer.</summary>
            private static EqualityComparerEntitySet _comparer = new EqualityComparerEntitySet();

            /// <summary>Gets the singleton comparer.</summary>
            public static EqualityComparerEntitySet Default
            {
                get
                {
                    return _comparer;
                }
            }

            #region IEqualityComparer<EntitySetBase> Members

            /// <summary>Equality check.</summary>
            /// <param name="x">Left.</param>
            /// <param name="y">Right.</param>
            /// <returns>true if names are same, false otherwise.</returns>
            public bool Equals(EntitySetBase x, EntitySetBase y)
            {
                return (x == null && y == null) ||
                       (x != null && y != null && x.Name == y.Name);
            }

            /// <summary>Gets hash code for EntitySetBase.</summary>
            /// <param name="obj">Object for which to get hash code.</param>
            /// <returns>Hash code for the name.</returns>
            public int GetHashCode(EntitySetBase obj)
            {
                return (null != obj) ? obj.Name.GetHashCode() : 0;
            }

            #endregion
        }
    }
}


text:
Web Testing Tool can be used for web application testing as well as for the web data scraping. For details [see](https://github.com/khomisha/wtt/blob/master/wtt.pdf)

## Building From Source

[Maven](http://maven.apache.org) is used to build and deploy.

Run build jar:

```sh
$ mvn package
```

The resulting jar files are in `target/`.

## Usage

Run Web Testing Tool

```sh
java -jar -Dlog4j.configuration=<your log4j>.properties wtt-0.0.1.jar <your wtt configuration file>.properties
```

## Contact

* mkhodonov@gmail.com

## Donate

[![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://load.payoneer.com/LoadToPage.aspx)

## License

Apache License, Version 2.0
Copyright (c) 2012-2014 Mikhail Khodonov.
It is free software and may be redistributed under the terms specified
in the LICENSE and NOTICE files.


text:
package com.yahoo.labs.samoa.moa.classifiers.core.splitcriteria;

import com.yahoo.labs.samoa.moa.core.ObjectRepository;
import com.yahoo.labs.samoa.moa.options.AbstractOptionHandler;
import com.yahoo.labs.samoa.moa.tasks.TaskMonitor;

public class VarianceReductionSplitCriterion extends AbstractOptionHandler implements SplitCriterion {

    private static final long serialVersionUID = 1L;

/*    @Override
    public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {

    	double N = preSplitDist[0];
    	double SDR = computeSD(preSplitDist);

    //	System.out.print("postSplitDists.length"+postSplitDists.length+"\n");
    	for(int i = 0; i < postSplitDists.length; i++)
    	{
    		double Ni = postSplitDists[i][0];
    		SDR -= (Ni/N)*computeSD(postSplitDists[i]);
    	}

        return SDR;
    }*/

    @Override
    public double getMeritOfSplit(double[] preSplitDist, double[][] postSplitDists) {
        double SDR=0.0;
    	double N = preSplitDist[0];
    	int count = 0;

			for (int i1 = 0; i1 < postSplitDists.length; i1++) {
				double[] postSplitDist = postSplitDists[i1];
				double Ni = postSplitDist[0];
				if (Ni >= 5.0) {
					count = count + 1;
				}
			}

    	if(count == postSplitDists.length){
    		SDR = computeSD(preSplitDist);
    		for(int i = 0; i < postSplitDists.length; i++)
        	{
        		double Ni = postSplitDists[i][0];
        		SDR -= (Ni/N)*computeSD(postSplitDists[i]);
        	}
    	}
    	return SDR;
    }

    @Override
    public double getRangeOfMerit(double[] preSplitDist) {
        return 1;
    }

    public static double computeSD(double[] dist) {

    	int N = (int)dist[0];
        double sum = dist[1];
        double sumSq = dist[2];
     //   return Math.sqrt((sumSq - ((sum * sum)/N))/N);
        return (sumSq - ((sum * sum)/N))/N;
    }

    @Override
    public void getDescription(StringBuilder sb, int indent) {
        // TODO Auto-generated method stub
    }

    @Override
    protected void prepareForUseImpl(TaskMonitor monitor,
            ObjectRepository repository) {
        // TODO Auto-generated method stub
    }

}


text:
ACCEPTED

#### According to
International Plant Names Index

#### Published in
J. Arnold Arbor. 32:297. 1951

#### Original name
null

### Remarks
null


text:
var httpProxy = require('http-proxy');
var http = require('http');
var https = require('https');
var agent = new http.Agent({ maxSockets: Number.MAX_VALUE });
var proxy = httpProxy.createProxy({ xfwd: true, agent: agent });
var fs = require('fs');
var nodeserverAdmin = require('./admin');
var os = require('os');
require('colors');
var core = require('./core');
var crypto = require('crypto');
var tls = require('tls');
var path = require('path');

module.exports = exports = function(inTerminal) {
	var self = this;
	this.websites = [];
	this.ports = [];
	this.securePorts = [];
	this.baseCerts = {};
	this.servers = [];
	this.config = null;
	this.unix = (os.platform() == 'darwin' || os.platform() == 'linux');
	this.running = false;
	this.socket = null;
	this.configFile = '/etc/nodeserver/nodeserver.config';

	core.terminal.nodeserver = this;
	core.sockets.nodeserver = this;
	core.workers.nodeserver = this;
	core.workers.proxy = proxy;

	/**
	 * Stop all process of server, read again the configuration file and restart the server
	 * @return {null}
	 */
	this.hotConfig = function() {
		this.stop();
		this.readConfigFile(this.configFile);
		this.start(false);
	};

	/**
	 * Get version number of nodeserver
	 * @return {string}
	 */
	this.getVersion = function() {
		return require('./package.json').version;
	};

	this.getWebsiteFromBinding = function(url, onlySecure, ignorePort) {
		onlySecure = onlySecure || false;
		ignorePort = ignorePort || false;

		var containBinding = function(url, bindings, hasRegex) {
			var bindingsCount = bindings.length;

			for(var i = 0; i < bindingsCount; i++) {
				var binding = bindings[i];

				if(hasRegex) {
					var regex = new RegExp('^' + binding + '$', 'gi');

					if(regex.test(url)) {
						return true;
					}
				} else {
					if(binding == url) {
						return true;
					}
				}
			}

			return false;
		};

		var getWebsite = function(url, websites) {
			var websitesCount = websites.length;

			for(var i = 0; i < websitesCount; i++) {
				var website = websites[i];

				if(website.security) {
					var result = containBinding(url, website.security.bindings, false);
					if(result) return website;
				}

				if(!onlySecure) {
					var result = containBinding(url, website.bindings, false);
					if(result) return website;
				}
			}

			for(var i = 0; i < websitesCount; i++) {
				var website = websites[i];

				if(website.security) {
					var result = containBinding(url, website.security.bindings, true);
					if(result) return website;
				}

				if(!onlySecure) {
					var result = containBinding(url, website.bindings, true);
					if(result) return website;
				}
			}
		};

		var thewebsite = getWebsite(url, self.websites);

		if(thewebsite == null) thewebsite = getWebsite(url + ':80', self.websites);
		if(thewebsite == null) thewebsite = getWebsite(url + ':443', self.websites);

		if(thewebsite) {
			return thewebsite;
		}

		for (var i = self.securePorts.length - 1; i >= 0; i--) {
			var secureWebsite = getWebsite(url + ':' + self.securePorts[i], self.websites);
			if(secureWebsite != null) {
				return secureWebsite;
			}
		}

		return thewebsite;
	};

	this.readConfigFile = function(configFile) {
		configFile = configFile || 'nodeserver.config';
		var config = null;

		if(!path.isAbsolute(configFile)) {
			configFile = path.resolve(process.cwd(), configFile);
		}

		if(fs.existsSync(configFile)) {
			this.configFile = configFile;
			config = fs.readFileSync(configFile);
		} else if(fs.existsSync(__dirname + configFile)) {
			this.configFile = __dirname + configFile;
			config = fs.readFileSync(__dirname + configFile);
		}  else if(fs.existsSync(__dirname + '/' + configFile)) {
			this.configFile = __dirname + '/' + configFile;
			config = fs.readFileSync(__dirname + '/' + configFile);
		} else if(fs.existsSync('/etc/nodeserver/nodeserver.config')) {
			this.configFile = '/etc/nodeserver/nodeserver.config';
			config = fs.readFileSync('/etc/nodeserver/nodeserver.config');
		}

		var json = JSON.parse(config);

		this.readConfig(json);
	};

	this.readConfig = function(config) {
		this.config = config;

		if(this.config == null) {
			return;
		}

		this.websites = [];

		if(this.config.sites && Array.isArray(this.config.sites)) {
			for(var i = 0; i < this.config.sites.length; i++) {
				this.addWebsite(this.config.sites[i]);
			}
		}

		if(this.config.nodeserver && this.config.nodeserver.admin) {
			if(this.config.nodeserver.admin.active) {
				if(!this.admin) {
					this.admin = new nodeserverAdmin(self);
					this.admin.adminInterface();
				}
			} else if(this.admin) {
				this.admin.stopAdminInterface();
			}
		}
	};

	this.addWebsite = function(site) {
		var website = new core.models.website(site, this);

		for(var i = 0; i < website.ports.http.length; i++) {
			this.addPort(website.ports.http[i]);
		}

		for(var i = 0; i < website.ports.https.length; i++) {
			this.addSecurePort(website.ports.https[i]);
		}

		if(website.security.certs != null && website.security.certs != undefined && website.security.certs.key != null) {
			this.baseCerts = website.security.certs;
		}

		this.websites.push(website);
		core.workers.start(website);
	};

	this.addPort = function(port) {
		for(var i = 0; i < this.ports.length; i++) {
			if(this.ports[i] == port) {
				return;
			}
		}

		this.ports.push(port);
	};

	this.addSecurePort = function(port) {
		for(var i = 0; i < this.securePorts.length; i++) {
			if(this.securePorts[i] == port) {
				return;
			}
		}

		this.securePorts.push(port);
	};

	this.start = function(started) {
		if(started === undefined) {
			if(this.unix) {
				core.sockets.start();

			}
		}

		var ports = this.ports.length;
		var securePorts = this.securePorts.length;

		for(var i = 0; i < ports; i++) {
			var server = http.createServer(core.workers.process);
			server.listen(this.ports[i]);

			this.servers.push(server);
		}

		var secureOptions = {
			SNICallback: function(domain, callback) {
				var website = self.getWebsiteFromBinding(domain, true, true);

				if(website) {
					var security = website.getSecurity(domain);
					/*{
						key: fs.readFileSync(website.security.certs.key),
						cert: fs.readFileSync(website.security.certs.cert)
					};*/

					if(website.security.certs.ca) {
						security.ca = [];

						for (var i = website.security.certs.ca.length - 1; i >= 0; i--) {
							security.ca.push(fs.readFileSync(website.security.certs.ca[i]));
						}
					}

					if(callback) {
						callback(null, tls.createSecureContext(security));
					} else {
						try {
							return tls.createSecureContext(security);
						} catch(e) {
							return crypto.createCredentials(security).context;
						}
					}
				} else {
					if(callback) {
						callback(true);
					} else {
						return true;
					}
				}
			},
			key: (self.baseCerts.key && fs.existsSync(self.baseCerts.key)) ? fs.readFileSync(self.baseCerts.key) : '',
			cert: (self.baseCerts.cert && fs.existsSync(self.baseCerts.cert)) ? fs.readFileSync(self.baseCerts.cert) : ''
		};

		for(var i = 0; i < securePorts; i++) {
			var server = https.createServer(secureOptions, core.workers.process);
			server.listen(this.securePorts[i]);
			this.servers.push(server);
		}

		this.running = true;
	};

	this.stop = function() {
		for(var i = 0; i < this.websites.length; i++) {
			if(this.websites[i].operations) {
				this.websites[i].operations.stop();
			}
		}

		for(var i = 0; i < this.servers.length; i++) {
			this.servers[i].close();
		}
	};

	this.restart = function() {
		this.stop();
		this.start();
	};

	this.exit = function() {
		this.stop();

		if(this.admin) {
			this.admin.stopAdminInterface();
		}

		if(self.unix && self.socket) {
			try {
				self.socket.close();
			} catch(ex) {}
		}
	};

	//process.setMaxListeners(100);

	process.on('exit', function() {
		self.exit();
	});

	/*process.on('uncaughtException', function(err) {
		/*eslint-disable*-/
		console.error('Nodeserver Error ' + err);
		console.error(arguments);
		/*eslint-enable*-/
	});*/

	process.on('SIGINT', function() {
		/*eslint-disable*/
		console.log('\nSayonara baby!!');
		/*eslint-enable*/
		process.exit(0);
	});

	this.terminal = core.terminal.process;

	if(inTerminal) {
		this.terminal(process.argv);
	}

	return self;
};


text:
package com.hunterdavis.arwiki;

import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.ImageFormat;
import android.graphics.Rect;
import android.graphics.YuvImage;
import android.hardware.Camera;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.Window;
import android.view.WindowManager;
import android.view.ViewGroup.LayoutParams;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.FrameLayout;

public class ARWiki extends Activity implements
CameraCallback {

	private FrameLayout cameraholder = null;
	private CameraSurface camerasurface = null;
	WebView engine;

	private class HelloWebViewClient extends WebViewClient {
	    @Override
	    public boolean shouldOverrideUrlLoading(WebView view, String url) {
	        view.loadUrl(url);
	        return true;
	    }
	}

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
		// Hide the window title.
		requestWindowFeature(Window.FEATURE_NO_TITLE);

		// hide the notification bar. That way, we can use the full screen.
		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
				WindowManager.LayoutParams.FLAG_FULLSCREEN);

		setContentView(R.layout.main);
		cameraholder = (FrameLayout) findViewById(R.id.camera_preview);

		setupPictureMode();

		navigateToWiki();

    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if ((keyCode == KeyEvent.KEYCODE_BACK) && engine.canGoBack()) {
            engine.goBack();
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }

    private void navigateToWiki() {
    	engine = (WebView) findViewById(R.id.web_engine);
    	engine.setWebViewClient(new HelloWebViewClient());
    	engine.setBackgroundColor(0);
    	engine.getSettings().setJavaScriptEnabled(true);
    	engine.loadUrl("http://www.wikipedia.org");
    }

	private void setupPictureMode() {
		camerasurface = new CameraSurface(this);

		cameraholder.addView(camerasurface, new LayoutParams(
				LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));

		camerasurface.setCallback(this);
	}

	@Override
	public void onJpegPictureTaken(byte[] data, Camera camera) {
		try {
			FileOutputStream outStream = new FileOutputStream(String.format(
					"/sdcard/%d.jpg", System.currentTimeMillis()));

			outStream.write(data);
			outStream.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

		camerasurface.startPreview();
	}

	@Override
	public void onPreviewFrame(byte[] data, Camera camera) {
		// Log.d("preview frame called","preview frame!");
		/*
		int width = camera.getParameters().getPreviewSize().width;
		int height = camera.getParameters().getPreviewSize().height;
		YuvImage yuvimage = new YuvImage(data, ImageFormat.NV21, width, height,
				null);
		Rect rect = new Rect(0, 0, width, height);
		ByteArrayOutputStream output_stream = new ByteArrayOutputStream();
		yuvimage.compressToJpeg(rect, 100, output_stream);
		Bitmap imagePreviewBitmap = BitmapFactory.decodeByteArray(
				output_stream.toByteArray(), 0, output_stream.size());
	    */
	}

	@Override
	public void onRawPictureTaken(byte[] data, Camera camera) {
	}

	@Override
	public void onShutter() {
	}

	@Override
	public String onGetVideoFilename() {
		String filename = String.format("/sdcard/%d.3gp",
				System.currentTimeMillis());

		return filename;
	}

}


text:
package Eldhelm::Util::Factory;

=pod

=head1 NAME

Eldhelm::Util::Factory - A utility class for constructing objects.

=head1 SYNOPSIS

This is a static class.

=head1 METHODS

=over

=cut

use strict;
use Carp;

=item getAbsoluteClassPath($name, $prefix, @paths) String or undef

Searches for class C<$name> prefixed by C<$prefix> in C<@INC> and the additional C<@paths>.
When a file is found in one of the locations its location is cached.

C<$name> String - The name of the class;
C<$prefix> String - Optional; A prefix or a String to be added before the class name;
C<@paths> Array - Optional; Additional paths to be searched;

=cut

my %absolutePathCache;

sub getAbsoluteClassPath {
	shift @_ if $_[0] eq __PACKAGE__;
	my ($name, $prefix, @paths) = @_;
	return $absolutePathCache{$name} if $absolutePathCache{$name};

	if ($prefix) {
		push @paths, map { "$_$prefix" } @INC;
	} else {
		push @paths, @INC;
	}

	foreach (@paths) {
		my $pt = "$_/$name";
		return $absolutePathCache{$name} = $pt if -f $pt;
	}

	return undef;
}

=item instance($name, %args) Object

Constructs an object from a class name in the C<Package::Name> format.

C<$name> String - The name of the class.
C<%args> Hash - constructor argments.

=cut

sub instance {
	shift @_ if $_[0] eq __PACKAGE__;
	my ($nm, %args) = @_;
	usePackage($nm);
	my $inst;
	eval { $inst = $nm->new(%args) };
	confess "Error while creaing instance '$nm': $@"
		if $@;
	return $inst;
}

sub usePackage {
	shift @_ if $_[0] eq __PACKAGE__;
	my ($nm) = @_;
	confess "Can not create instance without a name" if !$nm;
	eval "use $nm";
	confess "Can not use package '$nm': $@"
		if $@;
}

=item instance($name, $ref) Object

Blesses the C<$ref> to the class with C<$name>.

C<$name> String - The class name;
C<$ref> HashRef - The object to be blessed;

=cut

sub instanceFromScalar {
	shift @_ if $_[0] eq __PACKAGE__;
	my ($nm, $ref) = @_;
	usePackage($nm);
	my $inst;
	eval { $inst = bless $ref, $nm };
	confess "Error while creaing instance '$nm': $@"
		if $@;
	return $inst;
}

=item parseNotation($name) Array

Converts a dotted notation to a class name chunks. C<myPackage.myClass> will become C<('MyPackage','MyClass')>.

C<$name> String - A dotted notation;

=cut

sub parseNotation {
	shift @_ if $_[0] eq __PACKAGE__;
	my ($name) = @_;
	$name =~ s/_(.)/uc($1)/ge;
	my @nm = map { ucfirst $_ } split /[^a-z0-9]+/i, $name;
	return @nm;
}

=item packageFromNotation($ns, $name) String

Converts a dotted notation to a class name. C<myPackage.myClass> will become C<'MyPackage::MyClass'>, but prefixes it with the provided namespace.

C<$ns> String - The namespace to prefix the class name;
C<$name> String - A dotted notation;

=cut

sub packageFromNotation {
	shift @_ if $_[0] eq __PACKAGE__;
	my ($ns, $name) = @_;
	return join("::", $ns || (), parseNotation($name));
}

=item pathFromNotation($ns, $name) String

Converts a dotted notation to a file path. C<myPackage.myClass> will become C<'MyPackage/MyClass'>, but prefixes it with the provided namespace.

C<$ns> String - The namespace to prefix the class name;
C<$name> String - A dotted notation;

=cut

sub pathFromNotation {
	shift @_ if $_[0] eq __PACKAGE__;
	my ($ns, $name) = @_;
	return join("/", $ns || (), parseNotation($name));
}

=item instanceFromNotation($ns, $name, %args) String

Creates an object from a dotted notation. C<myPackage.myClass> will become the object C<MyPackage::MyClass>.

C<$ns> String - The namespace to prefix the class name;
C<$name> String - A dotted notation;
C<%args> Hash - Optional; Constructor arguments;

=cut

sub instanceFromNotation {
	shift @_ if $_[0] eq __PACKAGE__;
	my ($ns, $name, %args) = @_;
	my $inst;
	eval { $inst = instance(packageFromNotation($ns, $name), %args) };
	confess $@ if $@;
	return $inst;
}

=item instanceOf($ref, $ns, $name) 1 or undef

Checks whether the object instance C<$ref> is of the C<$name> represented in dotted notation from the C<$ns> namespace.

C<$ref> Object - An object instance to be checked;
C<$ns> String - The namespace to prefix the class name;
C<$name> String - A dotted notation;

=cut

sub instanceOf {
	shift @_ if $_[0] eq __PACKAGE__;
	my ($ref, $ns, $name) = @_;
	return $ref->isa(packageFromNotation($ns, $name));
}

=back

=head1 AUTHOR

Andrey Glavchev @ Essence Ltd. (http://essenceworks.com)

=head1 LICENSE

This software is Copyright (c) 2011-2015 of Essence Ltd.

Distributed undert the MIT license.

=cut

1;


text:
from djinni.support import MultiSet # default imported in all files
from djinni.exception import CPyException # default imported in all files
from djinni.pycffi_marshal import CPyBinary, CPyBoxedBool, CPyDate, CPyEnum, CPyObject, CPyObject, CPyObjectProxy, CPyPrimitive, CPyRecord, CPyString

from dh__list_bool import ListBoolHelper
from dh__map_int8_t_bool import MapInt8TBoolHelper
from dh__map_int8_t_bool import MapInt8TBoolProxy
from dh__set_bool import SetBoolHelper
from dh__set_bool import SetBoolProxy
from enum_data import EnumData
from _cffi import ffi, lib

from djinni import exception # this forces run of __init__.py which gives cpp option to call back into py to create exception

class AllDatatypes:
    c_data_set = MultiSet()

    @staticmethod
    def check_c_data_set_empty():
        assert len(AllDatatypes.c_data_set) == 0
        ListBoolHelper.check_c_data_set_empty()
        SetBoolHelper.check_c_data_set_empty()
        MapInt8TBoolHelper.check_c_data_set_empty()
        EnumData.check_c_data_set_empty()

    def __init__(self, booleanData, integer8Data, integer16Data, integer32Data, integer64Data, float32Data, float64Data, stringData, binaryData, dateData, listData, setData, mapData, optionalData, enum_data):
        self.booleanData = booleanData
        self.integer8Data = integer8Data
        self.integer16Data = integer16Data
        self.integer32Data = integer32Data
        self.integer64Data = integer64Data
        self.float32Data = float32Data
        self.float64Data = float64Data
        self.stringData = stringData
        self.binaryData = binaryData
        self.dateData = dateData
        self.listData = listData
        self.setData = setData
        self.mapData = mapData
        self.optionalData = optionalData
        self.enum_data = enum_data


text:
<?xml version="1.0" encoding="UTF-8"?>
<sem:triples uri="http://www.lds.org/vrl/geo-political/africa/sao-tome-and-principe" xmlns:sem="http://marklogic.com/semantics">
  <sem:triple>
    <sem:subject>http://www.lds.org/vrl/geo-political/africa/sao-tome-and-principe</sem:subject>
    <sem:predicate>http://www.w3.org/2004/02/skos/core#prefLabel</sem:predicate>
    <sem:object datatype="xsd:string" xml:lang="eng">Sao Tome and Principe</sem:object>
  </sem:triple>
  <sem:triple>
    <sem:subject>http://www.lds.org/vrl/geo-political/africa/sao-tome-and-principe</sem:subject>
    <sem:predicate>http://www.w3.org/2004/02/skos/core#inScheme</sem:predicate>
    <sem:object datatype="sem:iri">http://www.lds.org/concept-scheme/vrl</sem:object>
  </sem:triple>
  <sem:triple>
    <sem:subject>http://www.lds.org/vrl/geo-political/africa/sao-tome-and-principe</sem:subject>
    <sem:predicate>http://www.lds.org/core#entityType</sem:predicate>
    <sem:object datatype="sem:iri">http://www.schema.org/Place</sem:object>
  </sem:triple>
</sem:triples>


text:
<?xml version="1.0" encoding="UTF-8"?>
<sem:triples uri="http://www.lds.org/vrl/specific-reproductions/jesus-at-the-door-art-reproduction" xmlns:sem="http://marklogic.com/semantics">
  <sem:triple>
    <sem:subject>http://www.lds.org/vrl/specific-reproductions/jesus-at-the-door-art-reproduction</sem:subject>
    <sem:predicate>http://www.w3.org/2004/02/skos/core#prefLabel</sem:predicate>
    <sem:object datatype="xsd:string" xml:lang="eng">Jesus at the Door (Art Reproduction)</sem:object>
  </sem:triple>
  <sem:triple>
    <sem:subject>http://www.lds.org/vrl/specific-reproductions/jesus-at-the-door-art-reproduction</sem:subject>
    <sem:predicate>http://www.w3.org/2004/02/skos/core#inScheme</sem:predicate>
    <sem:object datatype="sem:iri">http://www.lds.org/concept-scheme/vrl</sem:object>
  </sem:triple>
  <sem:triple>
    <sem:subject>http://www.lds.org/vrl/specific-reproductions/jesus-at-the-door-art-reproduction</sem:subject>
    <sem:predicate>http://www.lds.org/core#entityType</sem:predicate>
    <sem:object datatype="sem:iri">http://www.lds.org/Topic</sem:object>
  </sem:triple>
</sem:triples>


text:
@interface ELAWalkingItemWithMockedCurrentLocation : ELAWalkingTime
@property (assign, nonatomic) CLLocationCoordinate2D mockedCurrentLocation;
@end

@implementation ELAWalkingItemWithMockedCurrentLocation
- (MKMapItem *)mapItemForCurrentLocation
{
    MKPlacemark *itemPlacemark = [[MKPlacemark alloc] initWithCoordinate:self.mockedCurrentLocation addressDictionary:@{}];
    return [[MKMapItem alloc] initWithPlacemark:itemPlacemark];
}
@end

@interface ELAWalkingTimeTests : XCTestCase

@end

@implementation ELAWalkingTimeTests

- (void)testGetWalkingTimeInSeconds
{
    CLLocationCoordinate2D coordinate = CLLocationCoordinate2DMake(51.567052, -0.080256);

    ELAWalkingItemWithMockedCurrentLocation *request = [[ELAWalkingItemWithMockedCurrentLocation alloc] initWithCoordinate:coordinate];

    request.mockedCurrentLocation = CLLocationCoordinate2DMake(51.564784, -0.073036); // About 5 minutes away

    StartBlock();

    __block NSUInteger result = 0;

    [request getWalkingTimeInSeconds:^(NSUInteger walkingTime, NSError *error) {
        result = walkingTime;
        EndBlock();
    }];

    WaitUntilBlockCompletes();

    XCTAssertTrue(result != 0);
    XCTAssertEqualWithAccuracy(result, 467, 50);
}

- (void)testCancelingARequest
{
    CLLocationCoordinate2D coordinate = CLLocationCoordinate2DMake(51.567052, -0.080256);

    ELAWalkingItemWithMockedCurrentLocation *request = [[ELAWalkingItemWithMockedCurrentLocation alloc] initWithCoordinate:coordinate];

    request.mockedCurrentLocation = CLLocationCoordinate2DMake(51.564784, -0.073036);

    __block BOOL blockCalled = NO;

    [request getWalkingTimeInSeconds:^(NSUInteger walkingTime, NSError *error) {
        blockCalled = YES;
    }];

    [request cancel];

    XCTAssertFalse(blockCalled);
}

- (void)testResumingRequest
{
    CLLocationCoordinate2D coordinate = CLLocationCoordinate2DMake(51.567052, -0.080256);

    ELAWalkingItemWithMockedCurrentLocation *request = [[ELAWalkingItemWithMockedCurrentLocation alloc] initWithCoordinate:coordinate];

    request.mockedCurrentLocation = CLLocationCoordinate2DMake(51.564784, -0.073036);

    [request getWalkingTimeInSeconds:^(NSUInteger walkingTime, NSError *error) {
    }];

    StartBlock();

    __block NSUInteger result = 0;

    [request getWalkingTimeInSeconds:^(NSUInteger walkingTime, NSError *error) {
        result = walkingTime;

        EndBlock();
    }];

    WaitUntilBlockCompletes();

    XCTAssertTrue(result != 0);
    XCTAssertEqualWithAccuracy(result, 467, 50);
}

@end


text:
package spaceinvaders.command.client;

import static spaceinvaders.command.ProtocolEnum.TCP;

import spaceinvaders.client.mvc.Controller;
import spaceinvaders.client.mvc.View;
import spaceinvaders.command.Command;
import spaceinvaders.game.EntityEnum;

/** Create a new entity. */
public class SpawnEntityCommand extends Command {
  private transient Controller executor;
  private Integer id;
  private EntityEnum type;
  private Integer posX;
  private Integer posY;

  SpawnEntityCommand() {
    super(SpawnEntityCommand.class.getName(),TCP);
  }

  /**
   * @param id entity id.
   * @param type entity type.
   * @param posX x-axis coordinate.
   * @param posY y-axis coordinate.
   *
   * @throws NullPointerException - if an argument is {@code null}.
   */
  public SpawnEntityCommand(int id, EntityEnum type, int posX, int posY) {
    this();
    this.id = id;
    this.type = type;
    this.posX = posX;
    this.posY = posY;
  }

  @Override
  public void execute() {
    for (View view : executor.getViews()) {
      view.spawnEntity(id,type,posX,posY);
    }
  }

  @Override
  public void setExecutor(Object executor) {
    if (executor instanceof Controller) {
      this.executor = (Controller) executor;
    } else {
      // This should never happen.
      throw new AssertionError();
    }
  }
}


text:
srcdir = .
top_srcdir = ..

pkgdatadir = $(datadir)/ml-pnet
pkglibdir = $(libdir)/ml-pnet
pkgincludedir = $(includedir)/ml-pnet
top_builddir = ..
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
INSTALL = /usr/bin/install -c
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
subdir = nunit20
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/configure.in
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
	$(ACLOCAL_M4)
mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
CONFIG_CLEAN_FILES =
depcomp =
am__depfiles_maybe =
SOURCES =
DIST_SOURCES =
RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
	html-recursive info-recursive install-data-recursive \
	install-exec-recursive install-info-recursive \
	install-recursive installcheck-recursive installdirs-recursive \
	pdf-recursive ps-recursive uninstall-info-recursive \
	uninstall-recursive
ETAGS = etags
CTAGS = ctags
DIST_SUBDIRS = $(SUBDIRS)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = ${SHELL} /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/missing --run aclocal-1.9
AMDEP_FALSE = #
AMDEP_TRUE =
AMTAR = ${SHELL} /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/missing --run tar
AUTOCONF = ${SHELL} /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/missing --run autoconf
AUTOHEADER = ${SHELL} /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/missing --run autoheader
AUTOMAKE = ${SHELL} /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/missing --run automake-1.9
AWK = gawk
CC = gcc
CCDEPMODE = depmode=none
CFLAGS = -g -O2
CPPFLAGS =
CSANT = /usr/local/bin/csant
CSANT_FLAGS = --compiler cscc -Dcscc="$(CSHARP_COMPILER)" -Dcscc.plugins.cs="$(CSHARP_PLUGIN)" --profile "$(top_srcdir)/profiles/$(PROFILE_NAME)" -Ddebug.flag="$(DEBUG_FLAG)" -Dilgac="$(CYG_ILGAC)" --assembly-cache "$(DESTDIR)$(CYG_CACHE)" -DFRAMEWORK_VERSION="$(FRAMEWORK_VERSION)" -DSECONDARY_VERSION="$(SECONDARY_VERSION)"
CSCC_FLAGS =
CSHARP_COMPILER = /usr/local/bin/cscc
CSHARP_COMPILER_CYGWIN = /usr/local/bin/cscc
CSHARP_PLUGIN =
CYGPATH =
CYGPATH_W = echo
CYG_CACHE = ${exec_prefix}/lib/cscc/lib
CYG_ILGAC = /usr/local/bin/ilgac
DEBUG_FLAG = true
DEFS = -DPACKAGE_NAME=\"\" -DPACKAGE_TARNAME=\"\" -DPACKAGE_VERSION=\"\" -DPACKAGE_STRING=\"\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE=\"ml-pnet\" -DVERSION=\"0.8.1\"
DEPDIR = .deps
ECHO_C =
ECHO_N = -n
ECHO_T =
EXEEXT =
FRAMEWORK_VERSION = 0.0.0.0
ILDD = /usr/local/bin/ildd
ILGAC = /usr/local/bin/ilgac
ILRUN = /usr/local/bin/ilrun
INSTALL_DATA = ${INSTALL} -m 644
INSTALL_PROGRAM = ${INSTALL}
INSTALL_SCRIPT = ${INSTALL}
INSTALL_STRIP_PROGRAM = ${SHELL} $(install_sh) -c -s
LDFLAGS =
LIBOBJS =
LIBS =
LN_S = ln -s
LTLIBOBJS =
MAINT = #
MAINTAINER_MODE_FALSE =
MAINTAINER_MODE_TRUE = #
MAKEINFO = ${SHELL} /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/missing --run makeinfo
ML_PNET_PATH = /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1
MONO_SOURCE_PATH = /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/mcs-sources
OBJEXT = o
PACKAGE = ml-pnet
PACKAGE_BUGREPORT =
PACKAGE_NAME =
PACKAGE_STRING =
PACKAGE_TARNAME =
PACKAGE_VERSION =
PATH_SEPARATOR = :
PNETLIB_PATH = /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/../pnetlib
PNET_PATH = /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/../pnet
PROFILE_NAME = framework1.1
SECONDARY_VERSION = 0.0.0.0
SET_MAKE =
SHELL = /bin/bash
STRIP =
TREECC = /usr/local/bin/treecc
TREECC_VERSION = 0.3.4
VERSION = 0.8.1
ac_ct_CC = gcc
am__fastdepCC_FALSE =
am__fastdepCC_TRUE = #
am__include = include
am__leading_dot = .
am__quote =
am__tar = ${AMTAR} chof - "$$tardir"
am__untar = ${AMTAR} xf -
bindir = ${exec_prefix}/bin
build_alias =
datadir = ${datarootdir}
datarootdir = ${prefix}/share
docdir = ${datarootdir}/doc/${PACKAGE}
dvidir = ${docdir}
exec_prefix = ${prefix}
host_alias =
htmldir = ${docdir}
includedir = ${prefix}/include
infodir = ${datarootdir}/info
install_sh = /home/jeff/dev/dev_apps/sand/qca_designer/lib/ml-pnet-0.8.1/install-sh
libdir = ${exec_prefix}/lib
libexecdir = ${exec_prefix}/libexec
localedir = ${datarootdir}/locale
localstatedir = ${prefix}/var
mandir = ${datarootdir}/man
mkdir_p = mkdir -p --
oldincludedir = /usr/include
pdfdir = ${docdir}
prefix = /usr/local
program_transform_name = s,x,x,
psdir = ${docdir}
sbindir = ${exec_prefix}/sbin
sharedstatedir = ${prefix}/com
sysconfdir = ${prefix}/etc
target_alias =
SUBDIRS = framework core util nunit-console
all: all-recursive

.SUFFIXES:
$(srcdir)/Makefile.in: # $(srcdir)/Makefile.am  $(am__configure_deps)
	@for dep in $?; do \
	  case '$(am__configure_deps)' in \
	    *$$dep*) \
	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
		&& exit 0; \
	      exit 1;; \
	  esac; \
	done; \
	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  --ignore-deps nunit20/Makefile'; \
	cd $(top_srcdir) && \
	  $(AUTOMAKE) --gnu  --ignore-deps nunit20/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
	@case '$?' in \
	  *config.status*) \
	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
	  *) \
	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
	esac;

$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh

$(top_srcdir)/configure: # $(am__configure_deps)
	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): # $(am__aclocal_m4_deps)
	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
uninstall-info-am:

# This directory's subdirectories are mostly independent; you can cd
# into them and run `make' without going through this Makefile.
# To change the values of `make' variables: instead of editing Makefiles,
# (1) if the variable is set in `config.status', edit `config.status'
#     (which will cause the Makefiles to be regenerated when you run `make');
# (2) otherwise, pass the desired values on the `make' command line.
$(RECURSIVE_TARGETS):
	@failcom='exit 1'; \
	for f in x $$MAKEFLAGS; do \
	  case $$f in \
	    *=* | --[!k]*);; \
	    *k*) failcom='fail=yes';; \
	  esac; \
	done; \
	dot_seen=no; \
	target=`echo $@ | sed s/-recursive//`; \
	list='$(SUBDIRS)'; for subdir in $$list; do \
	  echo "Making $$target in $$subdir"; \
	  if test "$$subdir" = "."; then \
	    dot_seen=yes; \
	    local_target="$$target-am"; \
	  else \
	    local_target="$$target"; \
	  fi; \
	  (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
	  || eval $$failcom; \
	done; \
	if test "$$dot_seen" = "no"; then \
	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
	fi; test -z "$$fail"

mostlyclean-recursive clean-recursive distclean-recursive \
maintainer-clean-recursive:
	@failcom='exit 1'; \
	for f in x $$MAKEFLAGS; do \
	  case $$f in \
	    *=* | --[!k]*);; \
	    *k*) failcom='fail=yes';; \
	  esac; \
	done; \
	dot_seen=no; \
	case "$@" in \
	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
	  *) list='$(SUBDIRS)' ;; \
	esac; \
	rev=''; for subdir in $$list; do \
	  if test "$$subdir" = "."; then :; else \
	    rev="$$subdir $$rev"; \
	  fi; \
	done; \
	rev="$$rev ."; \
	target=`echo $@ | sed s/-recursive//`; \
	for subdir in $$rev; do \
	  echo "Making $$target in $$subdir"; \
	  if test "$$subdir" = "."; then \
	    local_target="$$target-am"; \
	  else \
	    local_target="$$target"; \
	  fi; \
	  (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
	  || eval $$failcom; \
	done && test -z "$$fail"
tags-recursive:
	list='$(SUBDIRS)'; for subdir in $$list; do \
	  test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
	done
ctags-recursive:
	list='$(SUBDIRS)'; for subdir in $$list; do \
	  test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
	done

ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
	unique=`for i in $$list; do \
	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	  done | \
	  $(AWK) '    { files[$$0] = 1; } \
	       END { for (i in files) print i; }'`; \
	mkid -fID $$unique
tags: TAGS

TAGS: tags-recursive $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
		$(TAGS_FILES) $(LISP)
	tags=; \
	here=`pwd`; \
	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
	  include_option=--etags-include; \
	  empty_fix=.; \
	else \
	  include_option=--include; \
	  empty_fix=; \
	fi; \
	list='$(SUBDIRS)'; for subdir in $$list; do \
	  if test "$$subdir" = .; then :; else \
	    test ! -f $$subdir/TAGS || \
	      tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \
	  fi; \
	done; \
	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
	unique=`for i in $$list; do \
	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	  done | \
	  $(AWK) '    { files[$$0] = 1; } \
	       END { for (i in files) print i; }'`; \
	if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
	  test -n "$$unique" || unique=$$empty_fix; \
	  $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
	    $$tags $$unique; \
	fi
ctags: CTAGS
CTAGS: ctags-recursive $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
		$(TAGS_FILES) $(LISP)
	tags=; \
	here=`pwd`; \
	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
	unique=`for i in $$list; do \
	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
	  done | \
	  $(AWK) '    { files[$$0] = 1; } \
	       END { for (i in files) print i; }'`; \
	test -z "$(CTAGS_ARGS)$$tags$$unique" \
	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
	     $$tags $$unique

GTAGS:
	here=`$(am__cd) $(top_builddir) && pwd` \
	  && cd $(top_srcdir) \
	  && gtags -i $(GTAGS_ARGS) $$here

distclean-tags:
	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags

distdir: $(DISTFILES)
	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
	list='$(DISTFILES)'; for file in $$list; do \
	  case $$file in \
	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
	  esac; \
	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
	    dir="/$$dir"; \
	    $(mkdir_p) "$(distdir)$$dir"; \
	  else \
	    dir=''; \
	  fi; \
	  if test -d $$d/$$file; then \
	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
	    fi; \
	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
	  else \
	    test -f $(distdir)/$$file \
	    || cp -p $$d/$$file $(distdir)/$$file \
	    || exit 1; \
	  fi; \
	done
	list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
	  if test "$$subdir" = .; then :; else \
	    test -d "$(distdir)/$$subdir" \
	    || $(mkdir_p) "$(distdir)/$$subdir" \
	    || exit 1; \
	    distdir=`$(am__cd) $(distdir) && pwd`; \
	    top_distdir=`$(am__cd) $(top_distdir) && pwd`; \
	    (cd $$subdir && \
	      $(MAKE) $(AM_MAKEFLAGS) \
	        top_distdir="$$top_distdir" \
	        distdir="$$distdir/$$subdir" \
	        distdir) \
	      || exit 1; \
	  fi; \
	done
check-am: all-am
check: check-recursive
all-am: Makefile
installdirs: installdirs-recursive
installdirs-am:
install: install-recursive
install-exec: install-exec-recursive
install-data: install-data-recursive
uninstall: uninstall-recursive

install-am: all-am
	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am

installcheck: installcheck-recursive
install-strip:
	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
	  `test -z '$(STRIP)' || \
	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:

clean-generic:

distclean-generic:
	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)

maintainer-clean-generic:
	@echo "This command is intended for maintainers to use"
	@echo "it deletes files that may require special tools to rebuild."
clean: clean-recursive

clean-am: clean-generic mostlyclean-am

distclean: distclean-recursive
	-rm -f Makefile
distclean-am: clean-am distclean-generic distclean-tags

dvi: dvi-recursive

dvi-am:

html: html-recursive

info: info-recursive

info-am:

install-data-am:

install-exec-am:

install-info: install-info-recursive

install-man:

installcheck-am:

maintainer-clean: maintainer-clean-recursive
	-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic

mostlyclean: mostlyclean-recursive

mostlyclean-am: mostlyclean-generic

pdf: pdf-recursive

pdf-am:

ps: ps-recursive

ps-am:

uninstall-am: uninstall-info-am

uninstall-info: uninstall-info-recursive

.PHONY: $(RECURSIVE_TARGETS) CTAGS GTAGS all all-am check check-am \
	clean clean-generic clean-recursive ctags ctags-recursive \
	distclean distclean-generic distclean-recursive distclean-tags \
	distdir dvi dvi-am html html-am info info-am install \
	install-am install-data install-data-am install-exec \
	install-exec-am install-info install-info-am install-man \
	install-strip installcheck installcheck-am installdirs \
	installdirs-am maintainer-clean maintainer-clean-generic \
	maintainer-clean-recursive mostlyclean mostlyclean-generic \
	mostlyclean-recursive pdf pdf-am ps ps-am tags tags-recursive \
	uninstall uninstall-am uninstall-info-am

# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT: