text:
class AccountId;

class TestLoginScreenModel : public ash::LoginScreenModel {
 public:
  TestLoginScreenModel();

  TestLoginScreenModel(const TestLoginScreenModel&) = delete;
  TestLoginScreenModel& operator=(const TestLoginScreenModel&) = delete;

  ~TestLoginScreenModel() override;

  // ash::LoginScreenModel:
  void SetUserList(const std::vector<ash::LoginUserInfo>& users) override;
  void SetPinEnabledForUser(const AccountId& account_id,
                            bool is_enabled) override;
  void SetAvatarForUser(const AccountId& account_id,
                        const ash::UserAvatar& avatar) override;
  void SetFingerprintState(const AccountId& account_id,
                           ash::FingerprintState state) override;
  void NotifyFingerprintAuthResult(const AccountId& account_id,
                                   bool successful) override;
  void ResetFingerprintUIState(const AccountId& account_id) override;
  void SetSmartLockState(const AccountId& account_id,
                         ash::SmartLockState state) override;
  void NotifySmartLockAuthResult(const AccountId& account_id,
                                 bool successful) override;
  void EnableAuthForUser(const AccountId& account_id) override;
  void DisableAuthForUser(
      const AccountId& account_id,
      const ash::AuthDisabledData& auth_disabled_data) override;
  void SetTpmLockedState(const AccountId& user,
                         bool is_locked,
                         base::TimeDelta time_left) override;
  void SetTapToUnlockEnabledForUser(const AccountId& account_id,
                                    bool enabled) override;
  void ForceOnlineSignInForUser(const AccountId& account_id) override;
  void ShowEasyUnlockIcon(const AccountId& user,
                          const ash::EasyUnlockIconInfo& icon_info) override;
  void SetChallengeResponseAuthEnabledForUser(const AccountId& user,
                                              bool enabled) override;

  void UpdateWarningMessage(const std::u16string& message) override;
  void SetSystemInfo(bool show,
                     bool enforced,
                     const std::string& os_version_label_text,
                     const std::string& enterprise_info_text,
                     const std::string& bluetooth_name,
                     bool adb_sideloading_enabled) override;
  void SetPublicSessionLocales(const AccountId& account_id,
                               const std::vector<ash::LocaleItem>& locales,
                               const std::string& default_locale,
                               bool show_advanced_view) override;
  void SetPublicSessionDisplayName(const AccountId& account_id,
                                   const std::string& display_name) override;
  void SetPublicSessionKeyboardLayouts(
      const AccountId& account_id,
      const std::string& locale,
      const std::vector<ash::InputMethodItem>& keyboard_layouts) override;
  void SetPublicSessionShowFullManagementDisclosure(
      bool show_full_management_disclosure) override;
  void HandleFocusLeavingLockScreenApps(bool reverse) override;
  void NotifyOobeDialogState(ash::OobeDialogState state) override;
  void NotifyFocusPod(const AccountId& account_id) override;
};

#endif  // CHROME_BROWSER_UI_ASH_TEST_LOGIN_SCREEN_MODEL_H_


text:
function get_cwd() {
  pushd $(dirname ${0}) >/dev/null
  script_path=$(pwd -P)
  popd >/dev/null
  echo "${script_path}"
}

function get_snapshot_plugin() {
  if ! grep -q vagrant-vbox-snapshot <(vagrant plugin list); then
    vagrant plugin install vagrant-vbox-snapshot
  fi
}

function up() {
  vagrant status | awk 'NR==3' | grep -q 'not created'
  vm_does_not_exist=$?

  vagrant box list | grep -q ubuntu/bionic64
  has_box=$?

  if [[ ${has_box} -ne 0 ]]; then
    vagrant box add ubuntu/bionic64
  fi

  vagrant up

  if [[ ${vm_does_not_exist} -eq 0 ]]; then
    get_snapshot_plugin
    vagrant snapshot take 'post-bootstrap'
  fi
}

function down() {
  vagrant halt
}

function restore() {
  get_snapshot_plugin
  if grep 'post-bootstrap' <(vagrant snapshot list); then
    vagrant snapshot go 'post-bootstrap'
  fi
}

function run() {
  local cwd="$(get_cwd)"
  pushd "${cwd}" >/dev/null
  up
  if [[ -z "$1" ]] || [[ "$1" != "--no-clean" ]]; then
    echo "Restoring to initial state"
    restore
  else
    echo "Skipping restore to initial state"
  fi
  vagrant ssh -c "
  cd /home/vagrant/.go/src/github.com/docker-exec/dexec
  go get
  go install
  bats /bats/dexec.bats"
  down
  popd >/dev/null
}

function destroy() {
  local cwd="$(get_cwd)"
  pushd "${cwd}" >/dev/null
  echo "Destroying vagrant box"
  vagrant destroy -f

  popd >/dev/null
}

case $1 in
run)
  run $2;;
destroy)
  destroy;;
*)
  echo "Usage:"
  echo "   $0 run [--no-clean]"
  echo "   $0 destroy"
  ;;
esac

redpajama_set_name: RedPajamaGithub


text:
package com.CMPE202.Team31Project;

import com.jme3.bullet.collision.shapes.CollisionShape;
import com.jme3.bullet.control.RigidBodyControl;
import com.jme3.math.Quaternion;
import com.jme3.math.Vector3f;
import com.jme3.scene.Node;

/**
 * This class controls the movement of an object by making it "fly" towards
 * its target. It is extremely simple and always tries to fly in a straight line
 * directly to the target.
 *
 * @author Joshua P. Hemen
 */
public class DroneControl extends RigidBodyControl {
    private Node target;
    private Vector3f impulse = new Vector3f(0.15f, 0f, 0.15f); //default value
    private Vector3f steering;
    private Vector3f direction;
    private Quaternion rot = new Quaternion();
    private boolean doesFloat = false; //object will not float by default
    private float height = 0;

    // Allows the user to set a floating height value if desired
    public DroneControl(CollisionShape shape, float mass, Node target, float height) {
        super(shape, mass);
        this.target = target;
        this.height = height;
        doesFloat = true;
    }

    // Will not float if no value is passed for the height
    public DroneControl(CollisionShape shape, float mass, Node target) {
        super(shape, mass);
        this.target = target;
    }

    public DroneControl(CollisionShape shape, Node target) {
        super(shape, 1.0f);
        this.target = target;
    }

    @Override
    public void update(float tpf) {
        super.update(tpf);

        // Keep the object floating in the air if it is supposed to
        if(doesFloat) {
            setPhysicsLocation(getPhysicsLocation().setY(height));
        }

        // Update the steering influence
        steering = target.getWorldTranslation().clone();
        steering = steering.subtract(getPhysicsLocation()).normalize();

        // Actually move the object towards the target
        applyImpulse(steering.mult(impulse), Vector3f.ZERO);

        // Rotate the object to look at the target
        direction = getPhysicsLocation().subtract(target.getWorldTranslation());
        setPhysicsRotation(rot.fromAxes(Vector3f.UNIT_Y.cross(direction).normalize(),
                           Vector3f.UNIT_Y,
                           Vector3f.UNIT_Y.cross(direction).normalize()));
    }

    /*
     * @return the "speed" of the object.
     */
    public float getSpeed() {
        return getLinearVelocity().length();
    }

    /**
     * @param impulse the impulse to set
     */
    public void setImpulse(Vector3f impulse) {
        this.impulse = impulse;
    }
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Mycotaxon 49: 69 (1993)

#### Original name
Sporidesmiopsis goanensis Bhat & W.B. Kendr.

### Remarks
null


text:
$(function() {

  $.fn.datepicker.defaults.format = "dd.mm.yyyy";
  $.fn.datepicker.defaults.weekStart = 1;
  $.fn.datepicker.defaults.autoclose = true;
  $.fn.datepicker.defaults.todayHighlight = true;
  $.fn.datepicker.defaults.todayBtn = "linked";
  $.fn.datepicker.defaults.language = "de";
  $.fn.datepicker.defaults.calendarWeeks = true;

});


text:
// Type definitions for Electron v0.37.2
// Project: http://electron.atom.io/
// Definitions by: jedmao <https://github.com/jedmao/>, rhysd <https://rhysd.github.io>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

/// <reference path="github-electron.native-image.d.ts" />

declare namespace Electron {
	/**
	 * The clipboard module provides methods to perform copy and paste operations.
	 */
	interface Clipboard {
		/**
		 * @returns The contents of the clipboard as plain text.
		 */
		readText(type?: ClipboardType): string;
		/**
		 * Writes the text into the clipboard as plain text.
		 */
		writeText(text: string, type?: ClipboardType): void;
		/**
		 * @returns The contents of the clipboard as markup.
		 */
		readHtml(type?: ClipboardType): string;
		/**
		 * Writes markup to the clipboard.
		 */
		writeHtml(markup: string, type?: ClipboardType): void;
		/**
		 * @returns The contents of the clipboard as a NativeImage.
		 */
		readImage(type?: ClipboardType): NativeImage;
		/**
		 * Writes the image into the clipboard.
		 */
		writeImage(image: NativeImage, type?: ClipboardType): void;
		/**
		 * @returns The contents of the clipboard as RTF.
		 */
		readRtf(type?: ClipboardType): string;
		/**
		 * Writes the text into the clipboard in RTF.
		 */
		writeRtf(text: string, type?: ClipboardType): void;
		/**
		 * Clears everything in clipboard.
		 */
		clear(type?: ClipboardType): void;
		/**
		 * @returns Array available formats for the clipboard type.
		 */
		availableFormats(type?: ClipboardType): string[];
		/**
		 * Returns whether the clipboard supports the format of specified data.
		 * Note: This API is experimental and could be removed in future.
		 * @returns Whether the clipboard has data in the specified format.
		 */
		has(format: string, type?: ClipboardType): boolean;
		/**
		 * Reads the data in the clipboard of the specified format.
		 * Note: This API is experimental and could be removed in future.
		 */
		read(format: string, type?: ClipboardType): any;
		/**
		 * Writes data to the clipboard.
		 */
		write(data: {
			text?: string;
			rtf?: string;
			html?: string;
			image?: NativeImage;
		}, type?: ClipboardType): void;
	}

	type ClipboardType = '' | 'selection';
}


text:
dmg_package "Vagrant" do
  source node['vagrant']['url']
  checksum node['vagrant']['checksum']
  type "pkg"
  package_id "com.vagrant.vagrant"
  action :install
end


text:
// ----------------------------------------------------------------------------
// Copyright 2007-2017, GeoTelematic Solutions, Inc.
// All rights reserved
// ----------------------------------------------------------------------------
//
// Licensed 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.
//
// ----------------------------------------------------------------------------
// Description:
//  Base64 encoding/decoding
// ----------------------------------------------------------------------------
// Change History:
//  2017/02/02  Martin D. Flynn
//     -Initial release
// ----------------------------------------------------------------------------
package org.opengts.util;

import java.util.*;
import java.io.*;

/**
*** Tire state
**/

public class TireState
{

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    private static final int    DFT_MAX_TIRES       = 64; // absolute max number of tires
    private static final int    DFT_MAX_AXLES       = 16;
    private static final int    DFT_TIRES_PER_AXLE  =  4;

    private static       int    MAX_TIRES           = DFT_MAX_TIRES;
    private static       int    MAX_AXLES           = DFT_MAX_AXLES;
    private static       int    TIRES_PER_AXLE      = DFT_TIRES_PER_AXLE;

    /**
    *** Sets the configures default number of tires per axle
    *** @param tpa The tires-per-axle value (valid values 2,4,6,8)
    **/
    public static void SetTiresPerAxle(int tpa)
    {

        /* constrain tires-per-axle */
        if (tpa <= 0) {
            tpa = DFT_TIRES_PER_AXLE;
        } else
        if (tpa > 6) {
            tpa = DFT_TIRES_PER_AXLE;
        }

        /* round up to next even number */
        if ((tpa & 1) != 0) {
            tpa++;
        }

        /* constrain max tires and max axles */
        TIRES_PER_AXLE = tpa; // 2=32, 4=16, 6=10*, 8=8
        MAX_AXLES      = DFT_MAX_TIRES / tpa; // truncate
        MAX_TIRES      = MAX_AXLES * tpa;

    }

    /**
    *** Gets the configured default number of tires per axle
    *** @return The configured number of tires per axle
    **/
    public static int GetTiresPerAxle()
    {
        return TIRES_PER_AXLE;
    }

    /**
    *** Gets the configured default maximum number of tires
    *** @return The maximum number of supported tires
    **/
    public static int GetMaximumTires()
    {
        return MAX_TIRES;
    }

    /**
    *** Gets the configured default maximum number of axles
    *** @return The maximum number of supported axles
    **/
    public static int GetMaximumAxles()
    {
        return MAX_AXLES;
    }

    /**
    *** Gets the tire index for the specified axle/tire index
    *** @param axleNdx      The axle index
    *** @param axleTireNdx  The index of the tire on the axle (fron left to right)
    *** @return The tire index corresponding to the specified axle/tire index.
    **/
    public static int GetTireIndex(int axleNdx, int axleTireNdx)
    {
        return (axleNdx >= 0)? ((axleNdx * GetTiresPerAxle()) + axleTireNdx) : axleTireNdx;
    }

    /**
    *** Gets the axle index for the specified tire index
    *** @param tireNdx  The tire index
    *** @return The axle index corresponding to the specified tire index
    **/
    public static int GetAxleIndex(int tireNdx)
    {
        return (tireNdx >= 0)? (tireNdx / GetTiresPerAxle()) : -1;
    }

    /**
    *** Gets the axle/tire index for the specified tire index
    *** @param tireNdx  The tire index
    *** @return The tire index on the axle corresponding to the specified tire index
    **/
    public static int GetAxleTireIndex(int tireNdx)
    {
        return (tireNdx >= 0)? (tireNdx % GetTiresPerAxle()) : -1;
    }

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    public static final double  PSI_PER_KPA         = 0.14503773773020923;
    public static final double  KPA_PER_PSI         = 1.0 / PSI_PER_KPA; // 6.89475729316836
    public static final double  KPA_PER_BAR         = 100.0;
    public static final double  BAR_PER_KPA         = 1.0 / KPA_PER_BAR;
    public static final double  BAR_PER_PSI         = BAR_PER_KPA * KPA_PER_PSI; // 0.06894757293168
    public static final double  PSI_PER_BAR         = PSI_PER_KPA * KPA_PER_BAR; // 14.50377377302092
    public static final double  INVALID_PRESSURE    = -999.0;

    /**
    *** Returns true is the specified pressure is valid, false otherwise.
    *** (this method assumes that a zero or negative pressure is invalid)
    **/
    public static boolean IsValidPressure(double P)
    {
        return (!Double.isNaN(P) && (P > 0.0) && (P <= 999.0))? true : false;
    }

    /**
    *** kPa to PSI
    *** @param kPa kPa pressure
    *** @return PSI pressure
    **/
    public static double kPa2PSI(double kPa)
    {
        return kPa * PSI_PER_KPA;
    }

    /**
    *** PSI to kPa
    *** @param psi PSI pressure
    *** @return kPa pressure
    **/
    public static double PSI2kPa(double psi)
    {
        return psi * KPA_PER_PSI;
    }

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    public static final double  TEMP_LIMIT_LO       =  -273.15; // degrees C (absolute Kelvin)
    public static final double  TEMP_LIMIT_HI       =   500.0;  // degrees C
    public static final double  INVALID_TEMPERATURE = -9999.0;  // degrees C

    /**
    *** Returns true is the specified temperature is valid, false otherwise.
    *** @param C  The temperature to test
    **/
    public static boolean IsValidTemperature(double C)
    {
        return (!Double.isNaN(C) && (C >= TEMP_LIMIT_LO) && (C <= TEMP_LIMIT_HI))? true : false;
    }

    /**
    *** Fahrenheit to Celsius
    *** @param F Fahrenheit temperature
    *** @return Celsius temperature
    **/
    public static double F2C(double F)
    {
        return (F - 32.0) * 5.0 / 9.0;
    }

    /**
    *** Celsius to Fahrenheit
    *** @param C Celsius temperature
    *** @return Fahrenheit temperature
    **/
    public static double C2F(double C)
    {
        return (C * 9.0 / 5.0) + 32.0;
    }

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    /**
    *** Updates the specified TireState with values from the specified String.
    *** If the specified TireState is null, it will be created and returned if the String
    *** contains valid parsable data.  May return null if the specified TireState is null
    *** and the String cannot be parsed.
    *** If the TireState is created within this method, it will not have had the tire
    *** index set.
    *** @param ts        The TireState that will be updated
    *** @param s         The String containing the tire state information to add to the TireState instance
    *** @param tempOnly  True if the String contains only temperature values
    **/
    public static TireState UpdateTireState(TireState ts, String s, boolean tempOnly)
    {
        if (!StringTools.isBlank(s)) {
            // -- Pressure   :  "ActualPress[/PreferredPress][,Temperature]"
            // -- Temperature:  "Temperature"
            String PT[] = StringTools.split(s,',');
            String Pv   = (PT.length > 0)? PT[0] : null;
            String Tv   = (PT.length > 1)? PT[1] : null;

            // -- "Temperature" only?
            if (tempOnly) {
                if (StringTools.isBlank(Tv)) {
                    // -- this is the expected condition
                    Tv = Pv;    // move pressure to temperature
                    Pv = null;  // clear pressure
                } else {
                    // -- "tempOnly" is lying! (leaving "Tv" as is)
                }
            }

            // -- "Actual[/Preferred]" pressure
            if (!StringTools.isBlank(Pv)) {
                String _P[] = StringTools.split(Pv,'/');
                if (_P.length > 0) {
                    double P = StringTools.parseDouble(_P[0],INVALID_PRESSURE);
                    if (IsValidPressure(P)) {
                        if (ts == null) { ts = new TireState(); }
                        ts.setActualPressure(P);
                    }
                }
                if (_P.length > 1) {
                    double P = StringTools.parseDouble(_P[1],INVALID_PRESSURE);
                    if (IsValidPressure(P)) {
                        if (ts == null) { ts = new TireState(); }
                        ts.setPreferredPressure(P);
                    }
                }
            }

            // -- "Temperature"
            if (!StringTools.isBlank(Tv)) {
                double T = StringTools.parseDouble(Tv,INVALID_TEMPERATURE);
                if (IsValidTemperature(T)) {
                    if (ts == null) { ts = new TireState(); }
                    ts.setActualTemperature(T);
                }
            }

        }
        return ts;
    }

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    /**
    *** Parses the tire index from the specified String
    *** @param t  The String containing the tire index information in the format
    ***             "Txx", "Taa-x", or "Taax".
    *** @return The parsed tire index
    **/
    public static int ParseTireIndex(String t)
    {
        // "Txx", "Taa-x"
        if (StringTools.isBlank(t)) {
            return -1;
        }
        String Tx = t.startsWith("T")? t.substring(1).trim() : t;
        // --
        if ((Tx.length() == 1) || (Tx.length() == 2)) {
            // -- "[T]xx"
            int tireNdx = StringTools.parseInt(Tx,-1);
            if (tireNdx >= 0) {
                return tireNdx;
            }
        } else
        if (Tx.length() == 3) {
            // -- "[T]aax"
            int axleNdx = StringTools.parseInt(Tx.substring(0,2),-1);
            int tireNdx = StringTools.parseInt(Tx.substring(2)  ,-1);
            if ((axleNdx >= 0) && (tireNdx >= 0)) {
                return GetTireIndex(axleNdx, tireNdx);
            }
        } else
        if ((Tx.length() >= 4) && ((Tx.charAt(2) == '_') || (Tx.charAt(2) == '-'))) {
            // -- "[T]aa_x", "[T]aa-x
            int axleNdx = StringTools.parseInt(Tx.substring(0,2),-1);
            int tireNdx = StringTools.parseInt(Tx.substring(3),-1);
            if ((axleNdx >= 0) && (tireNdx >= 0)) {
                return GetTireIndex(axleNdx, tireNdx);
            }
        }
        return -1;
    }

    /**
    *** Parses the tire states from the specified String and returns them in the specified Map instance.
    *** May return null if the specified Map instance is null, and nothing is parsed from the specified
    *** String.
    *** @param s         The String containing the tire state list information
    *** @param map       The map containing the tire index and corresponding TireState
    *** @param tempOnly  True if the String contains temperature values only
    *** @return The map containing the tire index and corresponding TireState
    **/
    public static Map<Integer,TireState> ParseTireState(String s, boolean tempOnly, Map<Integer,TireState> map)
    {

        /* validate String */
        if (StringTools.isBlank(s)) {
            // -- invalid String, return map as-is
            return map;
        }
        s = s.trim().toUpperCase();

        /* pressure/temperature properties */
        if (s.startsWith("T") || (s.indexOf("=") >= 0)) {
            // -- Pressure   : "T01=25/30,100 T01=27/35 ..."
            // -- Temperature: "T01=100 T01=103 ..."
            RTProperties rtp = new RTProperties(s);
            for (Object K : rtp.getPropertyKeys()) {
                String Ks = (String)K;
                String Vs = rtp.getString(Ks,"");
                int tNdx = ParseTireIndex(Ks);
                if (tNdx >= 0) {
                    // -- tire index is valid
                    TireState ts = (map != null)? map.get(new Integer(tNdx)) : null;
                    if (ts == null) {
                        // -- new TireState
                        ts = new TireState().setTireIndex(tNdx);
                        if (map == null) { map = new HashMap<Integer,TireState>(); }
                        map.put(new Integer(tNdx), ts);
                    }
                    TireState.UpdateTireState(ts, Vs, tempOnly);
                }
            }
        } else
        if (s.indexOf(",") >= 0) {
            // -- "25,27,30,35,..."
            String P[] = StringTools.split(s,',');
            for (int tNdx = 0; (tNdx < P.length) && (tNdx < GetMaximumTires()); tNdx++) {
                String Vs = P[tNdx];
                TireState ts = (map != null)? map.get(new Integer(tNdx)) : null;
                if (ts == null) {
                    ts = new TireState().setTireIndex(tNdx);
                    if (map == null) { map = new HashMap<Integer,TireState>(); }
                    map.put(new Integer(tNdx), ts);
                }
                TireState.UpdateTireState(ts, Vs, tempOnly);
            }
        } else {
            // -- unable to recognize format
        }

        /* return map */
        return map;

    }

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    /**
    *** Gets the TireState for the specified tire index
    **/
    public static TireState GetTireStateForIndex(Map<Integer,TireState> tsm, int tireNdx)
    {
        if (!ListTools.isEmpty(tsm) && (tireNdx >= 0)) {
            return tsm.get(new Integer(tireNdx));
        }
        return null;
    }

    /**
    *** Gets the TireState for the specified tire index
    **/
    public static TireState GetTireStateForIndex(Map<Integer,TireState> tsm, int axleNdx, int axleTireNdx)
    {
        int tireNdx = GetTireIndex(axleNdx, axleTireNdx);
        return TireState.GetTireStateForIndex(tsm, tireNdx);
    }

    // --------------------------------

    /**
    *** Gets the TireState for the specified tire index
    **/
    public static TireState GetTireStateForIndex(TireState tsa[], int tireNdx)
    {
        if (!ListTools.isEmpty(tsa) && (tireNdx >= 0)) {
            for (TireState ts : tsa) {
                if ((ts != null) && (ts.getTireIndex() == tireNdx)) {
                    return ts;
                }
            }
        }
        return null;
    }

    /**
    *** Gets the TireState for the specified tire index
    **/
    public static TireState GetTireStateForIndex(TireState tsa[], int axleNdx, int axleTireNdx)
    {
        int tireNdx = GetTireIndex(axleNdx, axleTireNdx);
        return TireState.GetTireStateForIndex(tsa, tireNdx);
    }

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    /**
    *** Gets a String representation of the combined TireState array
    **/
    public static String GetTireStatePropertyString(Map<Integer,TireState> tsm)
    {
        if (!ListTools.isEmpty(tsm)) {
            // -- "T00_0=500/500,10 T00_1=500/500,10 ..."
            StringBuffer sb = new StringBuffer();
            for (Integer ti : tsm.keySet()) {
                TireState ts = tsm.get(ti);
                if (TireState.IsValid(ts)) {
                    if (sb.length() > 0) { sb.append(" "); }
                    ts.toKeyString(sb,true,-1/*dftNdx*/);
                    sb.append("=");
                    ts.getPressureString(sb);
                    if (ts.hasActualTemperature()) {
                        sb.append(",");
                        ts.getTemperatureString(sb);
                    }
                }
            }
            return sb.toString();
        } else {
            return "";
        }
    }

    /**
    *** Gets a String representation of the combined TireState array
    **/
    public static String GetTireStatePropertyString(TireState tsa[])
    {
        if (!ListTools.isEmpty(tsa)) {
            // -- "T00_0=500/500,10 T00_1=500/500,10 ..."
            StringBuffer sb = new StringBuffer();
            for (TireState ts : tsa) {
                if (TireState.IsValid(ts)) {
                    if (sb.length() > 0) { sb.append(" "); }
                    ts.toKeyString(sb,true,-1/*dftNdx*/);
                    sb.append("=");
                    ts.getPressureString(sb);
                    if (ts.hasActualTemperature()) {
                        sb.append(",");
                        ts.getTemperatureString(sb);
                    }
                }
            }
            return sb.toString();
        } else {
            return "";
        }
    }

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

    private int    tireNdx          = -1;
    private int    axleNdx          = -1;
    private int    axleTireNdx      = -1;

    private double actualPressure   = INVALID_PRESSURE;
    private double preferredPress   = INVALID_PRESSURE;
    private double temperature      = INVALID_TEMPERATURE;

    /**
    *** Constructor
    **/
    public TireState()
    {
        super();
        this.clearTireIndex();
        this.clearState();
    }

    /**
    *** Constructor
    **/
    public TireState(int tireNdx)
    {
        super();
        this.setTireIndex(tireNdx);
        this.clearState();
    }

    /**
    *** Constructor
    **/
    public TireState(int axleNdx, int tireNdx)
    {
        super();
        this.setTireIndex(axleNdx, tireNdx);
        this.clearState();
    }

    // ------------------------------------------------------------------------

    /**
    *** Clears the tire index
    **/
    public TireState clearTireIndex()
    {
        this.tireNdx     = -1;
        this.axleNdx     = -1;
        this.axleTireNdx = -1;
        return this;
    }

    /**
    *** Sets the tire index
    **/
    public TireState setTireIndex(int tireNdx)
    {
        this.tireNdx     = tireNdx;
        this.axleNdx     = GetAxleIndex(tireNdx);
        this.axleTireNdx = GetAxleTireIndex(tireNdx);
        return this;
    }

    /**
    *** Sets the tire index
    **/
    public TireState setTireIndex(int axleNdx, int tireNdx)
    {
        if (axleNdx < 0) {
            this.setTireIndex(tireNdx);
        } else {
            this.axleNdx     = axleNdx;
            this.axleTireNdx = tireNdx;
            this.tireNdx     = GetTireIndex(this.axleNdx, this.axleTireNdx);
        }
        return this;
    }

    // --------------------------------

    /**
    *** Returns true if this instance has an axle index
    **/
    public boolean hasAxleIndex()
    {
        return (this.axleNdx >= 0)? true : false;
    }

    /**
    *** Gets the axle index, or -1 if no axle index is defined
    **/
    public int getAxleIndex()
    {
        return this.axleNdx;
    }

    // --------------------------------

    /**
    *** Returns true if this instance has an axle/tire index
    **/
    public boolean hasAxleTireIndex()
    {
        return (this.axleTireNdx >= 0)? true : false;
    }

    /**
    *** Gets the axle/tire index, or -1 if no axle index is defined
    **/
    public int getAxleTireIndex()
    {
        return this.axleTireNdx;
    }

    // --------------------------------

    /**
    *** Returns true if this instance has a tire index
    **/
    public boolean hasTireIndex()
    {
        return (this.tireNdx >= 0)? true : false;
    }

    /**
    *** Gets the axle index, or -1 if no axle index is defined
    **/
    public int getTireIndex()
    {
        return this.tireNdx;
    }

    // ------------------------------------------------------------------------

    /**
    *** Clears the tire pressure/temperature state
    **/
    public TireState clearState()
    {
        this.setActualPressure(INVALID_PRESSURE);
        this.setPreferredPressure(INVALID_PRESSURE);
        this.setActualTemperature(INVALID_TEMPERATURE);
        return this;
    }

    /**
    *** Set tire pressure/temperature information
    **/
    public TireState updateState(String s, boolean tempOnly)
    {
        TireState.UpdateTireState(this, s, tempOnly);
        return this;
    }

    // ------------------------------------------------------------------------

    /**
    *** Gets the Actual Pressure from the specified TireState
    *** @param ts   The TireState from which the actual pressure will be returned
    *** @return The actual tire pressure
    **/
    public static double GetActualPressure(TireState ts)
    {
        if ((ts != null) && ts.hasActualPressure()) {
            return ts.getActualPressure();
        } else {
            return TireState.INVALID_PRESSURE;
        }
    }

    /**
    *** Returns true if this instance has a valid actual pressure
    **/
    public boolean hasActualPressure()
    {
        return TireState.IsValidPressure(this.getActualPressure());
    }

    /**
    *** Sets the actual tire pressure (in kPa)
    **/
    public void setActualPressure(double press)
    {
        this.actualPressure = TireState.IsValidPressure(press)? press : INVALID_PRESSURE;
    }

    /**
    *** Sets the actual tire pressure
    **/
    public double getActualPressure()
    {
        return this.actualPressure;
    }

    // ------------------------------------------------------------------------

    /**
    *** Gets the Preferred Pressure from the specified TireState
    *** @param ts   The TireState from which the preferred pressure will be returned
    *** @return The preferred tire pressure
    **/
    public static double GetPreferredPressure(TireState ts)
    {
        if ((ts != null) && ts.hasPreferredPressure()) {
            return ts.getPreferredPressure();
        } else {
            return TireState.INVALID_PRESSURE;
        }
    }

    /**
    *** Returns true if this instance has a valid preferred pressure
    **/
    public boolean hasPreferredPressure()
    {
        return TireState.IsValidPressure(this.getPreferredPressure());
    }

    /**
    *** Sets the preferred tire pressure (in kPa)
    **/
    public void setPreferredPressure(double press)
    {
        this.preferredPress = TireState.IsValidPressure(press)? press : INVALID_PRESSURE;
    }

    /**
    *** Sets the preferred tire pressure
    **/
    public double getPreferredPressure()
    {
        return this.preferredPress;
    }

    // ------------------------------------------------------------------------

    /**
    *** Gets the ratio of actual pressure divided by preferred pressure, minus one.
    *** Return will be:<br>
    ***     Double.NaN if the actual or preferred pressure is not available.<br>
    ***     < 0 if the pressure is low
    ***     > 0 if the pressure is high
    **/
    public double getPressureRatio(double dftPrefPress)
    {

        /* get actual pressure */
        double actPress = this.getActualPressure();
        if (!TireState.IsValidPressure(actPress)) {
            // -- no actual pressure value
            return Double.NaN;
        }

        /* get preferred pressure */
        double prefPress = this.getPreferredPressure();
        if (!TireState.IsValidPressure(prefPress) || (prefPress <= 0.0)) {
            if (TireState.IsValidPressure(dftPrefPress) && (dftPrefPress > 0.0)) {
                prefPress = dftPrefPress;
            } else {
                // -- no preferred pressure to compare against
                return Double.NaN;
            }
        }
        // -- prefPress is > 0.0 (no divide by zero errors)

        /* pressure ratio */
        return (actPress / prefPress) - 1.0; // ie. (90/100) - 1 = -0.10

    }

    // --------------------------------

    /**
    *** Returns true if the tire pressure is low
    **/
    public boolean isPressureLow(double pct, double dftPrefPress)
    {

        /* get ratio */
        double ratio = this.getPressureRatio(dftPrefPress);
        if (Double.isNaN(ratio)) {
            // -- unable to determine ratio
            return false;
        } else
        if (ratio > 0.0) {
            // -- high pressure
            return false;
        } else
        if (ratio == 0.0) {
            // -- exactly at preferred pressure
            return false;
        }

        /* pressure is low */
        if (Math.abs(ratio) < Math.abs(pct)) {
            // -- but not too low
            return false;
        }

        /* pressure is too low */
        return true;

    }

    /**
    *** Gets the first TireState instance with low pressure
    **/
    public static Collection<TireState> GetLowPressureTireState(Map<Integer,TireState> tsm, double pct, double dftPrefPress)
    {
        if (!ListTools.isEmpty(tsm)) {
            Vector<TireState> list = null;
            for (Integer tsi : tsm.keySet()) {
                TireState ts = tsm.get(tsi);
                if ((ts != null) && ts.isPressureLow(pct,dftPrefPress)) {
                    if (list == null) { list = new Vector<TireState>(); }
                    list.add(ts);
                }
            }
            return list;
        } else {
            return null;
        }
    }

    /**
    *** Gets the first TireState instance with low pressure
    **/
    public static Collection<TireState> GetLowPressureTireState(TireState tsa[], double pct, double dftPrefPress)
    {
        if (!ListTools.isEmpty(tsa)) {
            Vector<TireState> list = null;
            for (TireState ts : tsa) {
                if ((ts != null) && ts.isPressureLow(pct,dftPrefPress)) {
                    if (list == null) { list = new Vector<TireState>(); }
                    list.add(ts);
                }
            }
            return list;
        } else {
            return null;
        }
    }

    // --------------------------------

    /**
    *** Returns true if the tire pressure is low
    **/
    public boolean isPressureHigh(double pct, double dftPrefPress)
    {

        /* get ratio */
        double ratio = this.getPressureRatio(dftPrefPress);
        if (Double.isNaN(ratio)) {
            // -- unable to determine ratio
            return false;
        } else
        if (ratio < 0.0) {
            // -- low pressure
            return false;
        } else
        if (ratio == 0.0) {
            // -- exactly at preferred pressure
            return false;
        }

        /* pressure is high */
        //Print.logInfo("Compare ratio: "+Math.abs(ratio)+" <= "+Math.abs(pct));
        if (Math.abs(ratio) < Math.abs(pct)) {
            // -- but not too high
            return false;
        }

        /* pressure is too high */
        return true;

    }

    /**
    *** Gets the first TireState instance with high pressure
    **/
    public static Collection<TireState> GetHighPressureTireState(Map<Integer,TireState> tsm, double pct, double dftPrefPress)
    {
        if (!ListTools.isEmpty(tsm)) {
            Vector<TireState> list = null;
            for (Integer tsi : tsm.keySet()) {
                TireState ts = tsm.get(tsi);
                if ((ts != null) && ts.isPressureHigh(pct,dftPrefPress)) {
                    if (list == null) { list = new Vector<TireState>(); }
                    list.add(ts);
                }
            }
            return list;
        } else {
            return null;
        }
    }

    /**
    *** Gets the first TireState instance with high pressure
    **/
    public static Collection<TireState> GetHighPressureTireState(TireState tsa[], double pct, double dftPrefPress)
    {
        if (!ListTools.isEmpty(tsa)) {
            Vector<TireState> list = null;
            for (TireState ts : tsa) {
                if ((ts != null) && ts.isPressureHigh(pct,dftPrefPress)) {
                    if (list == null) { list = new Vector<TireState>(); }
                    list.add(ts);
                }
            }
            return list;
        } else {
            return null;
        }
    }

    // ------------------------------------------------------------------------

    /**
    *** Gets the Actual Temperature from the specified TireState
    *** @param ts   The TireState from which the temperature will be returned
    *** @return The tire temperature
    **/
    public static double GetActualTemperature(TireState ts)
    {
        if ((ts != null) && ts.hasActualTemperature()) {
            return ts.getActualTemperature();
        } else {
            return TireState.INVALID_TEMPERATURE;
        }
    }

    /**
    *** Returns true if this instance has a valid temperature
    **/
    public boolean hasActualTemperature()
    {
        return IsValidTemperature(this.getActualTemperature());
    }

    /**
    *** Sets the actual tire temperature (in C)
    **/
    public void setActualTemperature(double C)
    {
        this.temperature = TireState.IsValidTemperature(C)? C : INVALID_TEMPERATURE;
    }

    /**
    *** Sets the actual tire temperature (in C)
    **/
    public double getActualTemperature()
    {
        return this.temperature;
    }

    // --------------------------------

    /**
    *** Returns true if the tire pressure is low
    **/
    public boolean isTemperatureHigh(double highC)
    {
        if (!IsValidTemperature(highC)) {
            return false;
        } else
        if (!this.hasActualTemperature()) {
            return false;
        } else {
            double C = this.getActualTemperature();
            return (C > highC)? true : false;
        }
    }

    /**
    *** Gets the first TireState instance with high pressure
    **/
    public static Collection<TireState> GetHighTemperatureTireState(Map<Integer,TireState> tsm, double highC)
    {
        if (!ListTools.isEmpty(tsm) && IsValidTemperature(highC)) {
            Vector<TireState> list = null;
            for (Integer tsi : tsm.keySet()) {
                TireState ts = tsm.get(tsi);
                if ((ts != null) && ts.isTemperatureHigh(highC)) {
                    if (list == null) { list = new Vector<TireState>(); }
                    list.add(ts);
                }
            }
            return list;
        } else {
            return null;
        }
    }

    /**
    *** Gets the first TireState instance with high temperature
    **/
    public static Collection<TireState> GetHighTemperatureTireState(TireState tsa[], double highC)
    {
        if (!ListTools.isEmpty(tsa) && IsValidTemperature(highC)) {
            Vector<TireState> list = null;
            for (TireState ts : tsa) {
                if ((ts != null) && ts.isTemperatureHigh(highC)) {
                    if (list == null) { list = new Vector<TireState>(); }
                    list.add(ts);
                }
            }
            return list;
        } else {
            return null;
        }
    }

    // ------------------------------------------------------------------------

    /**
    *** Returns true if the specified TireState is valid
    **/
    public static boolean IsValid(TireState ts)
    {
        return ((ts != null) && ts.isValid())? true : false;
    }

    /**
    *** Returns trus if this instance has a defined valid pressure or temperature
    **/
    public boolean isValid()
    {
        if (this.hasActualPressure()) {
            return true;
        } else
        if (this.hasPreferredPressure()) {
            return true;
        } else
        if (this.hasActualTemperature()) {
            return true;
        } else {
            return false;
        }
    }

    // ------------------------------------------------------------------------

    /**
    *** Gets a Key name for this instance, representing the Tire Index
    *** @param sb  The StringBuffer to which the Key name will be appended
    *** @return The StringBuffer containing the Key name
    **/
    public StringBuffer toKeyString(StringBuffer sb, boolean perAxle, int dftNdx)
    {
        // -- tire index
        int tireNdx     = -1;
        int axleNdx     = -1;
        int axleTireNdx = -1;
        if (this.hasTireIndex()) {
            tireNdx     = this.getTireIndex();
            axleNdx     = this.getAxleIndex();
            axleTireNdx = this.getAxleTireIndex();
        } else
        if (dftNdx >= 0) {
            tireNdx     = dftNdx;
            axleNdx     = GetAxleIndex(dftNdx);
            axleTireNdx = GetAxleTireIndex(dftNdx);
        }
        // -- assemble key
        if (sb == null) {
            sb = new StringBuffer();
        }
        sb.append("T");
        if (tireNdx < 0) {
            // -- no nothing
        } else
        if (perAxle) {
            // -- "T01-2"
            sb.append(StringTools.format(axleNdx,"00")).append("-").append(axleTireNdx);
        } else {
            // -- "T09"
            sb.append(StringTools.format(tireNdx,"00"));
        }
        return sb;
    }

    /**
    *** Gets a Key name for this instance, representing the Tire Index
    *** @param sb  The StringBuffer to which the Key name will be appended
    *** @return The StringBuffer containing the Key name
    **/
    public String toKeyString(boolean perAxle, int dftNdx)
    {
        return this.toKeyString(null,perAxle,dftNdx).toString();
    }

    // --------------------------------

    /**
    *** Gets a String representation of the pressure values in the format "Actual/Preferred".
    *** Returns only the "Actual" pressure if the Preferred pressure is not available.
    **/
    public StringBuffer getPressureString(String prefix, StringBuffer sb)
    {
        if (sb == null) {
            sb = new StringBuffer();
        }
        if (this.hasActualPressure() || this.hasPreferredPressure()) {
            if (prefix != null) {
                sb.append(prefix);
            }
            if (this.hasActualPressure()) {
                sb.append(StringTools.format(this.getActualPressure(),"0.0"));
            }
            if (this.hasPreferredPressure()) {
                sb.append("/");
                sb.append(StringTools.format(this.getPreferredPressure(),"0.0"));
            }
        }
        return sb;
    }

    /**
    *** Gets a String representation of the pressure values in the format "Actual/Preferred".
    *** Returns only the "Actual" pressure if the Preferred pressure is not available.
    **/
    public StringBuffer getPressureString(StringBuffer sb)
    {
        return this.getPressureString(null, sb);
    }

    /**
    *** Gets a String representation of the pressure values in the format "Actual/Preferred".
    *** Returns only the "Actual" pressure if the Preferred pressure is not available.
    **/
    public String getPressureString(String prefix)
    {
        return this.getPressureString(prefix,null).toString();
    }

    // --------------------------------

    /**
    *** Gets a String representation of the temperature value.
    **/
    public StringBuffer getTemperatureString(String prefix, StringBuffer sb)
    {
        if (sb == null) {
            sb = new StringBuffer();
        }
        if (this.hasActualTemperature()) {
            if (prefix != null) {
                sb.append(prefix);
            }
            sb.append(StringTools.format(this.getActualTemperature(),"0.0"));
        }
        return sb;
    }

    /**
    *** Gets a String representation of the temperature value.
    **/
    public StringBuffer getTemperatureString(StringBuffer sb)
    {
        return this.getTemperatureString(null, sb);
    }

    /**
    *** Gets a String representation of the temperature value.
    **/
    public String getTemperatureString(String prefix)
    {
        return this.getTemperatureString(prefix,null).toString();
    }

    // --------------------------------

    /**
    *** Return a String representation of this instance, in the following format: <br>
    ***     Taa_t=PRESSURE/PREFERRED,TEMPERATURE
    *** Where:<br>
    ***     aa          is the Axle index <br>
    ***     t           is the Axle/Tire index <br>
    ***     PRESSURE    is the actual tire pressure <br>
    ***     PREFERRED   is the preferred tire pressure (optional) <br>
    ***     TEMPERATURE is the tire temperature (optional) <br>
    **/
    public String toString()
    {
        StringBuffer sb = new StringBuffer();
        // --
        this.toKeyString(sb,true,-1);
        sb.append("=");
        // --
        this.getPressureString(sb);
        if (this.hasActualTemperature()) {
            sb.append(",");
            this.getTemperatureString(sb);
        }
        // --
        return sb.toString();
    }

    // ------------------------------------------------------------------------
    // ------------------------------------------------------------------------

}


text:
<?php
return array (
  'Create new group' => 'Opret ny gruppe',
  'Edit group' => 'Rediger gruppe',
  'Delete' => 'Slet',
  'Description' => 'Beskrivelse',
  'Group name' => 'Gruppe navn',
  'Ldap DN' => 'LDAP DN',
  'Save' => 'Gem',
);


text:
'use strict';

var models = require('./index');

/**
 * @class
 * Initializes a new instance of the Foo class.
 * @constructor
 * The URIs that are used to perform a retrieval of a public blob, queue or
 * table object.
 * @member {object} [barPoint] Bar point
 *
 * @member {object} [barPoint.recursivePoint] Recursive Endpoints
 *
 * @member {string} [barPoint.recursivePoint.blob] Gets the blob endpoint.
 *
 * @member {string} [barPoint.recursivePoint.queue] Gets the queue endpoint.
 *
 * @member {string} [barPoint.recursivePoint.table] Gets the table endpoint.
 *
 * @member {object} [barPoint.recursivePoint.dummyEndPoint] Dummy EndPoint
 *
 * @member {object} [barPoint.recursivePoint.fooPoint] Foo point
 *
 */
function Foo(parameters) {
  if (parameters !== null && parameters !== undefined) {
    if (parameters.barPoint) {
      this.barPoint = new models['Bar'](parameters.barPoint);
    }
  }
}

/**
 * Validate the payload against the Foo schema
 *
 * @param {JSON} payload
 *
 */
Foo.prototype.serialize = function () {
  var payload = {};
  if (this['barPoint']) {
    payload['BarPoint'] = this['barPoint'].serialize();
  }

  return payload;
};

/**
 * Deserialize the instance to Foo schema
 *
 * @param {JSON} instance
 *
 */
Foo.prototype.deserialize = function (instance) {
  if (instance) {
    if (instance['BarPoint']) {
      this['barPoint'] = new models['Bar']().deserialize(instance['BarPoint']);
    }
  }

  return this;
};

module.exports = Foo;


text:
rem |
rem | This batch file is used to get together all the files for export.
rem |
rem | It copies the EOSAI.dll (release and debug versions) and all the required include files into the Export directory
rem | The Export directory contains all the data that is needed by the game
rem | When the game is released, it only needs to include the EOSAI.dll (release version, not the debug version or include files)
rem |
rem | If you want to use the build with your own strategy game, you can either point to the files in the \Export directory,
rem | or create another cpin task at the end of this batch file.  Write "cpin -r \Export\*.* [YOUR_DIRECTORY]" to recursively
rem | copy everything to a target directory.
rem |
rem | This (_ConstructExportPackage.bat) should be called in Project->Build Events->Post Build Events

set ExportDirectory=.\Build\Export\

echo Copying EOS Example Code to EOSAI (we just want a copy as an example; we don't compile it)
rem cpin c:/programming/EOS/source/EOSAIInterface_EOS.cpp %ExportDirectory%\ExampleCode\.
rem cpin c:/programming/EOS/source/EOSAIInterface_EOS.h %ExportDirectory%\ExampleCode\.
rem cpin c:/programming/EOS/source/EOSAIWorldDistanceTool_EOS.cpp %ExportDirectory%\ExampleCode\.
rem cpin c:/programming/EOS/source/EOSAIWorldDistanceTool_EOS.h %ExportDirectory%\ExampleCode\.
cpin ../../EOS/source/EOSAIInterface_EOS.cpp %ExportDirectory%\ExampleCode\.
cpin ../../EOS/source/EOSAIInterface_EOS.h %ExportDirectory%\ExampleCode\.
cpin ../../EOS/source/EOSAIWorldDistanceTool_EOS.cpp %ExportDirectory%\ExampleCode\.
cpin ../../EOS/source/EOSAIWorldDistanceTool_EOS.h %ExportDirectory%\ExampleCode\.

echo Copying EOSAI Include files to the Export Directory (so EOS can access it)
rem cpin -c Build\Debug\EOSAI-Debug.dll %ExportDirectory%\EOSAI-Debug.dll
rem cpin -c Build\Debug\EOSAI-Debug.lib %ExportDirectory%\EOSAI-Debug.lib
cpin -c Build\Debug\EOSAI-Debug.dll %ExportDirectory%\EOSAI-Debug.dll
cpin -c Build\Debug\EOSAI-Debug.lib %ExportDirectory%\EOSAI-Debug.lib
cpin -c Build\Release\EOSAI.dll %ExportDirectory%\EOSAI.dll
cpin -c Build\Release\EOSAI.lib %ExportDirectory%\EOSAI.lib
rem cpin -c Build\Release\EOSAI.dll %ExportDirectory%\EOSAI.dll
rem cpin -c Build\Release\EOSAI.lib %ExportDirectory%\EOSAI.lib
cpin -r %ExportDirectory%\*.dll ..\EOS\

echo %ExportDirectory%
cpin .\AIPlayerDesc.h %ExportDirectory%\Include\
cpin .\EOSAIActionRequirement.h %ExportDirectory%\Include\
cpin .\EOSAIActionScheduler.h %ExportDirectory%\Include\
cpin .\AIPlayer.h %ExportDirectory%\Include\
cpin .\EOSAIAirfield.h %ExportDirectory%\Include\
cpin .\EOSAIAirUnitPathwayData.h %ExportDirectory%\Include\
cpin .\EOSAIAttackVs2.h %ExportDirectory%\Include\
cpin .\EOSAIBCArray.h %ExportDirectory%\Include\
cpin .\EOSAIBCArray2.h %ExportDirectory%\Include\
cpin .\EOSAIBCDumbArray1D.h %ExportDirectory%\Include\
cpin .\EOSAIBCDumbArray2D.h %ExportDirectory%\Include\
cpin .\EOSAIBrain.h %ExportDirectory%\Include\
cpin .\EOSAIBuildingDescription.h %ExportDirectory%\Include\
cpin .\EOSAIBuildManager.h %ExportDirectory%\Include\
cpin .\EOSAIBuildOption.h %ExportDirectory%\Include\
cpin .\EOSAIBuildOrder.h %ExportDirectory%\Include\
cpin .\EOSAIMain.h %ExportDirectory%\Include\

cpin .\City.h %ExportDirectory%\Include\
cpin .\EOSAICitResSummary.h %ExportDirectory%\Include\
cpin .\EOSAICitResUnitSummary.h %ExportDirectory%\Include\
cpin .\EOSAICitResValueMultiplier.h %ExportDirectory%\Include\
cpin .\EOSAICombatUnitType.h %ExportDirectory%\Include\
cpin .\EOSAICommonData.h %ExportDirectory%\Include\
cpin .\EOSAIEnumAttackGoal.h %ExportDirectory%\Include\
cpin .\EOSAIEnumFieldOrders.h %ExportDirectory%\Include\
cpin .\EOSAIEnumForeignRelations.h %ExportDirectory%\Include\
cpin .\EOSAIEnumGeoPlan.h %ExportDirectory%\Include\
cpin .\EOSAIEnumGeoSituation.h %ExportDirectory%\Include\
cpin .\EnumAIMailResponse.h %ExportDirectory%\Include\
cpin .\EOSAIEnumMovementType.h %ExportDirectory%\Include\
cpin .\EOSAIEnumPoiObjectType.h %ExportDirectory%\Include\
cpin .\EOSAIEnumTradeAgreementResponse.h %ExportDirectory%\Include\
cpin .\EOSAIEnumTradeAgreementState.h %ExportDirectory%\Include\
cpin .\EOSAIEnumTypeOfUnit.h %ExportDirectory%\Include\
cpin .\EOSAIForeignRelationsSituation.h %ExportDirectory%\Include\
cpin .\EOSAIForeignRelationsState.h %ExportDirectory%\Include\
cpin .\EOSAIGamePlayer.h %ExportDirectory%\Include\
cpin .\EOSAIGameRules.h %ExportDirectory%\Include\
cpin .\EOSAIGenericRegion.h %ExportDirectory%\Include\
cpin .\EOSAIGenericRegionManager.h %ExportDirectory%\Include\
cpin .\EOSAIGeo.h %ExportDirectory%\Include\
cpin .\EOSAIGeoView.h %ExportDirectory%\Include\
cpin .\EOSAIGlobalForeignRelations.h %ExportDirectory%\Include\
cpin .\EOSAIIntSet.h %ExportDirectory%\Include\
cpin .\EOSAIListSort.h %ExportDirectory%\Include\
cpin .\EOSAIListOwned.h %ExportDirectory%\Include\
cpin .\EOSAIListUnowned.h %ExportDirectory%\Include\
cpin .\EOSAILimitedList.h %ExportDirectory%\Include\
cpin .\EOSAILocation.h %ExportDirectory%\Include\
cpin .\EOSAILogFile.h %ExportDirectory%\Include\
cpin .\EOSAILongSet.h %ExportDirectory%\Include\
cpin .\EOSAIJobCapability.h %ExportDirectory%\Include\
cpin .\EOSAIJobRole.h %ExportDirectory%\Include\
cpin .\EOSAIJobsToDo.h %ExportDirectory%\Include\
cpin .\EOSAIMail.h %ExportDirectory%\Include\
cpin .\EOSAIMailResponse.h %ExportDirectory%\Include\
cpin .\EOSAIMathFunction.h %ExportDirectory%\Include\

cpin .\MessageFromAI.h %ExportDirectory%\Include\
cpin .\MessageFromAI_DeclareWar.h %ExportDirectory%\Include\
cpin .\MessageFromAI_TradeDesires.h %ExportDirectory%\Include\
cpin .\MessageFromAI_TradeOffer.h %ExportDirectory%\Include\
cpin .\MessageToAI.h %ExportDirectory%\Include\

cpin .\EOSAIMovementDescription.h %ExportDirectory%\Include\
cpin .\EOSAIMovementUnitType.h %ExportDirectory%\Include\
cpin .\EOSAIMultiRegion2.h %ExportDirectory%\Include\
cpin .\EOSAIMultiRegionManager2.h %ExportDirectory%\Include\
cpin .\EOSAINationalSummary.h %ExportDirectory%\Include\
cpin .\EOSAINationalSummary3.h %ExportDirectory%\Include\
cpin .\EOSAIPathfinderPoint.h %ExportDirectory%\Include\
cpin .\EOSAIPlayerOwnershipMap.h %ExportDirectory%\Include\
cpin .\EOSAIPlayerManager.h %ExportDirectory%\Include\
cpin .\PoiObject.h %ExportDirectory%\Include\
cpin .\PoiObjectState.h %ExportDirectory%\Include\
cpin .\EOSAIPoiMobile.h %ExportDirectory%\Include\
cpin .\EOSAIObjectActionProgression.h %ExportDirectory%\Include\
cpin .\EOSAIQuickCombatCalculation.h %ExportDirectory%\Include\
cpin .\EOSAIQuickCombatResults.h %ExportDirectory%\Include\
cpin .\EOSAISerial.h %ExportDirectory%\Include\
cpin .\EOSAIRegion2.h %ExportDirectory%\Include\
cpin .\EOSAIRegionManager2.h %ExportDirectory%\Include\
cpin .\EOSAIRegionPathfinder.h %ExportDirectory%\Include\
cpin .\EOSAIRegionPathwayMap.h %ExportDirectory%\Include\
cpin .\EOSAIRegionMapToEverywhere.h %ExportDirectory%\Include\
cpin .\EOSAIResource.h %ExportDirectory%\Include\
cpin .\EOSAIResourceEffectsSummary.h %ExportDirectory%\Include\
cpin .\EOSAIRoad2.h %ExportDirectory%\Include\
cpin .\EOSAISimpleCharMap.h %ExportDirectory%\Include\
cpin .\EOSAISimpleMap.h %ExportDirectory%\Include\
cpin .\EOSAIStopwatch2.h %ExportDirectory%\Include\
cpin .\EOSAIStrategicAI.h %ExportDirectory%\Include\
cpin .\EOSAIStrategicAIOrder.h %ExportDirectory%\Include\
cpin .\EOSAIStringAndFloat.h %ExportDirectory%\Include\
cpin .\EOSAIStringAndFloatSet.h %ExportDirectory%\Include\
cpin .\EOSAIStringAndLongSet.h %ExportDirectory%\Include\
cpin .\EOSAITacticalProject2.h %ExportDirectory%\Include\
cpin .\EOSAITacticalProject2Strategy.h %ExportDirectory%\Include\
cpin .\EOSAITaskForce3.h %ExportDirectory%\Include\
cpin .\EOSAITechnologyDesc.h %ExportDirectory%\Include\
cpin .\EOSAITechTreeNode.h %ExportDirectory%\Include\
cpin .\EOSAITerrainBasedValue.h %ExportDirectory%\Include\
cpin .\EOSAIThoughtDatabase.h %ExportDirectory%\Include\
cpin .\EOSAITradeAgreement.h %ExportDirectory%\Include\
cpin .\EOSAITradeAgreementResponse.h %ExportDirectory%\Include\
cpin .\EOSAITransportsSet.h %ExportDirectory%\Include\
cpin .\EOSAIUnit.h %ExportDirectory%\Include\
cpin .\EOSAIUnit2CombatCapability.h %ExportDirectory%\Include\
cpin .\EOSAIUnitPathwayFinder.h %ExportDirectory%\Include\
cpin .\EOSAIUnitPathwayResultStep.h %ExportDirectory%\Include\
cpin .\EOSAIUnitSummary.h %ExportDirectory%\Include\
cpin .\EOSAIUnitActionIdea.h %ExportDirectory%\Include\
cpin .\EOSAIUnitActionStack.h %ExportDirectory%\Include\
cpin .\EOSAIUnitPathwayResult.h %ExportDirectory%\Include\
cpin .\EOSAIUnitPathwayPredefinedStep.h %ExportDirectory%\Include\
cpin .\EOSAIUnitTemplate.h %ExportDirectory%\Include\
cpin .\EOSAIUnitTemplateSet.h %ExportDirectory%\Include\
cpin .\EOSAIUnitTemplateAndFloat.h %ExportDirectory%\Include\
cpin .\EOSAIUnitTemplatesAndFloat.h %ExportDirectory%\Include\
cpin .\EOSAIUnitsubsetPermission.h %ExportDirectory%\Include\

rem |
rem |
cpin .\EOSAIPublic.h %ExportDirectory%\Include\
cpin .\EOSAIIncludes.h %ExportDirectory%\Include\
cpin .\EOSAISettings.h %ExportDirectory%\Include\

rem |
rem | Copy EOSAI interfaces to the Export\Include directory
rem |
cpin .\EOSAIWorldDistanceTool.h %ExportDirectory%\Include\
cpin .\EOSAIWorldDistanceTool.cpp %ExportDirectory%\Include\
cpin .\EOSAIInterface.h %ExportDirectory%\Include\
cpin .\EOSAIInterface.cpp %ExportDirectory%\Include\

rem |
rem | If you want the files copied somewhere else, edit the line below:
rem | cpin -r \Export\*.* [YOUR_DIRECTORY]
rem |
rem | cpin -r %ExportDirectory%\*.* c:\programming\EOS\Source\EOSAI\
rem cpin -r %ExportDirectory%\*.* c:\programming\EOSAI-1.0\EOSAI\
rem cpin -r %ExportDirectory%\*.dll C:\Programming\EOS\Build\
rem cpin -r %ExportDirectory%\*.* ..\..\EOSAI-1.0\EOSAI\
rem cpin -r %ExportDirectory%\*.dll ..\..\EOS\Build\
rem cpin -r %ExportDirectory%\*.dll ..\EOS\

echo Done


text:
class AddSubmittedAtToBusinesses < ActiveRecord::Migration
  def change
    add_column :businesses, :submitted_at, :datetime
  end
end


text:
class AddHexValueToHairColor < ActiveRecord::Migration
  def change
    add_column :hair_colors, :hex_value, :string
  end
end


text:
package com.dremio.common.utils;

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

import java.util.UUID;

import org.junit.Test;

/**
 * Unit tests for UUIDAdapter
 */
public class TestUUIDAdapter {

  @Test
  public void testGet16BytesFromUUID() {
    UUID uuid = UUID.randomUUID();
    byte[] result = UUIDAdapter.getBytesFromUUID(uuid);
    assertEquals("Expected result to be a byte array with 16 elements.", 16, result.length);
  }

  @Test
  public void testGenerateSameUUIDFromBytes() {
    UUID uuid = UUID.randomUUID();
    byte[] bytes = UUIDAdapter.getBytesFromUUID(uuid);
    UUID reconstructedUUID = UUIDAdapter.getUUIDFromBytes(bytes);
    assertEquals(uuid, reconstructedUUID);
  }

  @Test
  public void testShouldNotGenerateSameUUIDFromBytes() {
    UUID uuid = UUID.fromString("38400000-8cf0-11bd-b23e-10b96e4ef00d");
    byte[] result = UUIDAdapter.getBytesFromUUID(uuid);
    UUID newUuid = UUID.nameUUIDFromBytes(result);
    assertFalse(uuid.equals(newUuid));
  }
}


text:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      android:orientation="vertical">

    <TextView
        android:text="登录"
        android:textSize="30sp"
        android:gravity="center"
        android:layout_width="match_parent"
        android:layout_height="50dp" />
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <TextView
            android:text="账号"
            android:textSize="25sp"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content" />
        <EditText
            android:id="@+id/userID"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="请输入账号"/>

    </LinearLayout>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <TextView
            android:text="密码"
            android:textSize="25sp"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content" />
        <EditText
            android:id="@+id/userPassword"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="请输入密码"
            android:inputType="textPassword"/>

    </LinearLayout>
    <Button
        android:id="@+id/login"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="登录"
        android:textSize="20sp"
        android:gravity="center"/>
    <Button
        android:id="@+id/register"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="快速注册"
        android:layout_gravity="bottom|right"/>

</LinearLayout>


text:
  #include "base/ints.h"
#endif

namespace base {                // Based on C++0x threads lib

  class thread {
  public:
    typedef void* native_handle_type;
#if LAF_WINDOWS
    typedef uint32_t native_id_type;
#else
    typedef void* native_id_type;
#endif

    // Create an instance to represent the current thread
    thread();

    // Create a new thread without arguments
    template<class Callable>
    thread(const Callable& f) {
      launch_thread(new func_wrapper0<Callable>(f));
    }

    // Create a new thread with one argument
    template<class Callable, class A>
    thread(const Callable& f, A a) {
      launch_thread(new func_wrapper1<Callable, A>(f, a));
    }

    // Create a new thread with two arguments
    template<class Callable, class A, class B>
    thread(const Callable& f, A a, B b) {
      launch_thread(new func_wrapper2<Callable, A, B>(f, a, b));
    }

    ~thread();

    bool joinable() const;
    void join();
    void detach();

    native_id_type native_id() const;

    class details {
    public:
      static void thread_proxy(void* data);
    };

  private:
    native_handle_type m_native_handle;
#if LAF_WINDOWS
    native_id_type m_native_id;
#endif

    class func_wrapper {
    public:
      virtual ~func_wrapper() { }
      virtual void operator()() = 0;
    };

    void launch_thread(func_wrapper* f);

    template<class Callable>
    class func_wrapper0 : public func_wrapper {
    public:
      Callable f;
      func_wrapper0(const Callable& f) : f(f) { }
      void operator()() { f(); }
    };

    template<class Callable, class A>
    class func_wrapper1 : public func_wrapper {
    public:
      Callable f;
      A a;
      func_wrapper1(const Callable& f, A a) : f(f), a(a) { }
      void operator()() { f(a); }
    };

    template<class Callable, class A, class B>
    class func_wrapper2 : public func_wrapper {
    public:
      Callable f;
      A a;
      B b;
      func_wrapper2(const Callable& f, A a, B b) : f(f), a(a), b(b) { }
      void operator()() { f(a, b); }
    };

  };

  namespace this_thread
  {
    void yield();
    void sleep_for(double seconds);
    thread::native_id_type native_id();
  }

  // This class joins the thread in its destructor.
  class thread_guard {
    thread& m_thread;
  public:
    explicit thread_guard(thread& t) : m_thread(t) { }
    ~thread_guard()
    {
      if (m_thread.joinable())
        m_thread.join();
    }
  };

}

#endif


text:
<?php

namespace Sonata\Component\Product;

/**
 * Interface PriceComputableInterface
 *
 * This interface describes required fields for price computation
 *
 * @author Vincent Composieux <vincent.composieux@gmail.com>
 */
interface PriceComputableInterface
{
    /**
     * Sets unit price
     *
     * @param float $unitPrice
     */
    public function setUnitPrice($unitPrice);

    /**
     * Returns the unit price
     *
     * if $vat = true, returns the unit price with vat
     *
     * @param boolean $vat
     *
     * @return float
     */
    public function getUnitPrice($vat = false);

    /**
     * Sets price
     *
     * @param float $price
     */
    public function setPrice($price);

    /**
     * Returns price of the element (including quantity)
     *
     * @param boolean $vat
     *
     * @return float
     */
    public function getPrice($vat = false);

    /**
     * Sets if price is including VAT
     *
     * @param boolean $priceIncludingVat
     */
    public function setPriceIncludingVat($priceIncludingVat);

    /**
     * Returns if price is including VAT
     *
     * @return boolean
     */
    public function isPriceIncludingVat();

    /**
     * Sets VAT rate
     *
     * @param float $vatRate
     */
    public function setVatRate($vatRate);

    /**
     * Gets VAT rate
     *
     * @return float
     */
    public function getVatRate();

    /**
     * Sets quantity
     *
     * @param integer $quantity
     */
    public function setQuantity($quantity);

    /**
     * Gets quantity
     *
     * @return integer $quantity
     */
    public function getQuantity();
}


text:
package org.cradle.repository.cassandra;

import org.cradle.reporting.SystemReportingService;
import org.springframework.cassandra.core.WriteOptions;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.data.cassandra.core.CassandraTemplate;

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Host;
import com.datastax.driver.core.HostDistance;
import com.datastax.driver.core.Metadata;
import com.datastax.driver.core.Session;

/**
 * @author 	Sherief Shawky
 * @date 	Aug 12, 2014
 */
public class CassandraContext {

	private AnnotationConfigApplicationContext context;

	private SystemReportingService reportingService;

	public void setReportingService(SystemReportingService reportingService) {

		this.reportingService = reportingService;
	}

	public void init(){

		context = new AnnotationConfigApplicationContext(CassandraConfig.class);

		printNodeInfo();
	}

	private void printNodeInfo() {

		Cluster cluster = getSession().getCluster();

		Metadata metadata = cluster.getMetadata();

		reportingService.info(this.getClass().getSimpleName(), SystemReportingService.CONSOLE, "Connected to cluster: " + metadata.getClusterName());

		for ( Host host : metadata.getAllHosts() ) {

			reportingService.info(this.getClass().getSimpleName(), SystemReportingService.CONSOLE, "Datacenter: " + host.getDatacenter() + "; Host: " + host.getAddress() + "; Rack: "
					+ host.getRack());
		}

		reportingService.info(
				this.getClass().getSimpleName(), SystemReportingService.CONSOLE,
				"Core Connections Per Host: " + cluster.getConfiguration().getPoolingOptions().getCoreConnectionsPerHost(HostDistance.LOCAL)
				);

		reportingService.info(
				this.getClass().getSimpleName(), SystemReportingService.CONSOLE,
				"Max Connections Per Host: " + cluster.getConfiguration().getPoolingOptions().getMaxConnectionsPerHost(HostDistance.LOCAL)
				);

		reportingService.info(
				this.getClass().getSimpleName(), SystemReportingService.CONSOLE,
				"Min Simultaneous Connections Per Host: " + cluster.getConfiguration().getPoolingOptions().getMinSimultaneousRequestsPerConnectionThreshold(HostDistance.LOCAL)
				);

		reportingService.info(
				this.getClass().getSimpleName(), SystemReportingService.CONSOLE,
				"Max Simultaneous Connections Per Host: " + cluster.getConfiguration().getPoolingOptions().getMaxSimultaneousRequestsPerConnectionThreshold(HostDistance.LOCAL)
				);

	}

	public void destroy(){

		context.close();
	}

	public CassandraTemplate getCassandraTemplate(){

		return (CassandraTemplate) context.getBean("cassandraOperations");
	}

	public Session getSession(){
		return (Session) context.getBean("cassandraSession");
	}

	public WriteOptions getWriteOptions(){
		return (WriteOptions) context.getBean("WriteOptions");
	}

}


text:
import { Injectable } from '@angular/core';
import { Http, Response, Headers, Request, RequestOptions, RequestMethod, RequestOptionsArgs } from '@angular/http';
import { Observable } from 'rxjs';
import 'rxjs/add/operator/map';
import 'rxjs/add/operator/catch';
import 'rxjs/add/operator/toPromise';
import { Config } from "./config/config";
declare var $: any;

@Injectable()
export class CoreService {

    private baseUrl: string;

    constructor(public _http: Http) {
        this.baseUrl = Config.apiUrl;
    }

    public post(uri: string, bodyParam: object, url?: string, options?: RequestOptionsArgs) {
        let postUrl = this.baseUrl + uri;
        if(!!url) postUrl = url;
        return this._request(RequestMethod.Post, postUrl, $.param(bodyParam), options);
    }

    private _request(method: RequestMethod, url: string, body?: string, options?: RequestOptionsArgs): Observable<Response> {
        let requestOptions = new RequestOptions(Object.assign({
            method: method,
            url: url,
            body: body
        }, options));

        if (!requestOptions.headers) {
            requestOptions.headers = new Headers();
            requestOptions.headers.append('Content-Type', 'application/x-www-form-urlencoded');
        }

        return Observable.create((observer) => {
            this._http.request(new Request(requestOptions))
                .map(res => {
                    return this.processResponseData(res);
                })
                .finally(() => {

                })
                .subscribe(
                (res) => {
                    observer.next(res);
                    observer.complete();
                },
                (err) => {
                    switch (err.status) {
                        case 401:
                            //intercept 401
                            observer.error(err);
                            break;
                        default:
                            observer.error(err);
                            break;
                    }
                })
        })
    }

    private processResponseData(response) {
        response._body = response._body.replace("response(", "");
        response._body = response._body.replace("})", "}");
        return response.json();
    }

}


text:
<!doctype html>

  <meta charset="utf-8">
  <title>amp-bind : amp-live-list</title>
  <link rel="canonical" href="amps.html" >
  <meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1">

  <button on="tap:AMP.setState({liveListText: 'hello world'})" id="changeLiveListTextButton"></button>
  <amp-live-list id="liveList" data-poll-interval="20000" data-max-items-per-page="2">
    <button update id="liveListUpdateButton" on="tap:liveList.update"></button>

unbound

  </amp-live-list>

  <button id="triggerBindApplicationButton" on="tap:AMP.setState({})">Trigger application</button>


text:
package com.google.appengine.demos.jdoexamples;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class NamedCounterServlet extends HttpServlet {

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    String action = req.getParameter("submit");
    if (action == null) {
      throw new ServletException("No action supplied!");
    }
    if (action.equals("Reset")) {
      NamedCounterUtils.reset(req.getParameter("name"));
    } else if (action.equals("Offset")) {
      NamedCounterUtils.addAndGet(req.getParameter("name"),
                                  Integer.parseInt(req.getParameter("delta")));
    } else if (action.equals("Get")) {
    }
    resp.sendRedirect("/namedcounter.jsp?name=" + req.getParameter("name"));
  }
}


text:
<?xml version="1.0" encoding="UTF-8"?>

	<item value="Default C++ source template" key="LastUsedSourceTemplate"/>
	<item value="Default C++ header template" key="LastUsedHeaderTemplate"/>

		<item value="227191" key="searchFlags"/>
		<item value="false" key="caseSensitive"/>
		<list key="previousPatterns">
			<item value="add"/>
			<item value="relString"/>
			<item value="alleleFreqs"/>
		</list>

		<item value="true" key="show_structs"/>
		<item value="false" key="show_lowlevel"/>
		<item value="false" key="show_macros"/>
		<item value="false" key="show_variables"/>
		<item value="401" key="width"/>
		<item value="false" key="show_functions"/>
		<item value="false" key="show_enums"/>
		<item value="719" key="height"/>
		<item value="true" key="show_classes"/>
		<item value="false" key="show_typedefs"/>
		<item value="false" key="show_namespaces"/>
		<item value="false" key="show_unions"/>
		<item value="25" key="y"/>
		<item value="722" key="x"/>

		<item value="802" key="size.width"/>
		<item value="253" key="size.height"/>


text:
<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="@dimen/intrinsic_padding"
    tools:context=".main.post.createPost.CreatePostActivity">

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:focusableInTouchMode="true"
        android:focusable="true">

        <RelativeLayout
            android:id="@+id/imageContainer"
            android:layout_width="match_parent"
            android:layout_height="300dp"
            android:layout_marginBottom="@dimen/intrinsic_padding"
            android:layout_alignParentTop="true">

            <ImageView
                android:id="@+id/imageView"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:src="@drawable/ic_stub"
                android:focusableInTouchMode="true"
                android:focusable="true" />

            <ProgressBar
                android:id="@+id/progressBar"
                style="?android:attr/progressBarStyleLarge"
                android:layout_width="40dp"
                android:layout_height="40dp"
                android:layout_centerInParent="true"
                android:visibility="gone" />

        </RelativeLayout>

        <android.support.design.widget.TextInputLayout
            android:id="@+id/input_layout_title"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginBottom="@dimen/intrinsic_padding"
            android:layout_below="@+id/imageContainer">

            <EditText
                android:id="@+id/titleEditText"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:hint="@string/hint_title"
                android:inputType="textMultiLine" />

        </android.support.design.widget.TextInputLayout>

        <android.support.design.widget.TextInputLayout
            android:id="@+id/input_layout_description"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"

            android:layout_below="@+id/input_layout_title">

            <EditText
                android:id="@+id/descriptionEditText"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:gravity="start"
                android:hint="@string/hint_description"
                android:inputType="textMultiLine" />

        </android.support.design.widget.TextInputLayout>

    </RelativeLayout>

</ScrollView>


text:
using UnityEngine;
using Vexe.Runtime.Types;

namespace VFWExamples
{
#if UNITY_EDITOR
	public static class BSOMenuItem
	{
		[UnityEditor.MenuItem("Tools/Vexe/Examples/Create BSO Asset")]
		public static void CreateAsset()
		{
			var ex = ScriptableObject.CreateInstance<BSOExample>();
			UnityEditor.AssetDatabase.CreateAsset(ex, "Assets/BSO.asset");
		}
	}
#endif

	public class BSOExample : BaseScriptableObject
	{
		[Tags, PerItem]
		public string[] tags;

		[SelectEnum]
		public KeyCode Jump;

		[BetterV3]
		public Vector3 Target;

		[Show]
		void method()
		{
			Debug.Log("method");
		}

		[Inline]
		public Object obj;
	}
}


text:
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical"
    android:background="@android:color/background_light" >

    <LinearLayout
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="30dp"
        android:gravity="center_horizontal"
        android:orientation="vertical" >
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:gravity="center"
            android:textColor="@android:color/black"
            android:textSize="28sp"
            android:typeface="serif"
            android:textStyle="italic"
            android:text="@string/app_name" />
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:gravity="center"
            android:textColor="@android:color/black"
            android:textSize="16sp"
            android:typeface="serif"
            android:textStyle="italic"
            android:text="@string/promo"
            android:layout_marginTop="8dp" />
    </LinearLayout>
    <LinearLayout
        android:layout_width="215dip"
        android:layout_height="match_parent"
        android:layout_centerHorizontal="true"
        android:orientation="vertical"
        android:layout_gravity="center"
        android:gravity="center_vertical">
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:gravity="center"
            android:textColor="@android:color/black"
            android:text="@string/get_started"
            android:layout_marginBottom="10dp" />
         <com.facebook.widget.LoginButton
             android:id="@+id/facebook_sign_in_button"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:layout_gravity="center_horizontal"
             android:layout_marginTop="5dp"
             android:layout_marginBottom="5dp" />
         <com.google.android.gms.common.SignInButton
             android:id="@+id/google_sign_in_button"
             android:layout_width="match_parent"
             android:layout_height="wrap_content" />
     </LinearLayout>

 </LinearLayout>


text:
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace ServantHR.Database.Tests
{
    [TestClass]
    public class UnitTest1
    {
    }
}


text:
using Microsoft.VisualStudio.Services.Agent.Util;
using System;
using Xunit;

namespace Microsoft.VisualStudio.Services.Agent.Tests.Util
{
    public sealed class ArgUtilL0
    {
        [Fact]
        [Trait("Level", "L0")]
        [Trait("Category", "Common")]
        public void Equal_MatchesObjectEquality()
        {
            using (TestHostContext hc = new TestHostContext(this))
            {
                Tracing trace = hc.GetTrace();

                // Arrange.
                string expected = "Some string".ToLower();  // ToLower is required to avoid reference equality
                string actual = "Some string".ToLower();    // due to compile-time string interning.

                // Act/Assert.
                ArgUtil.Equal(expected: expected, actual: actual, name: "Some parameter");
            }
        }

        [Fact]
        [Trait("Level", "L0")]
        [Trait("Category", "Common")]
        public void Equal_MatchesReferenceEquality()
        {
            using (TestHostContext hc = new TestHostContext(this))
            {
                Tracing trace = hc.GetTrace();

                // Arrange.
                object expected = new object();
                object actual = expected;

                // Act/Assert.
                ArgUtil.Equal(expected: expected, actual: actual, name: "Some parameter");
            }
        }

        [Fact]
        [Trait("Level", "L0")]
        [Trait("Category", "Common")]
        public void Equal_MatchesStructEquality()
        {
            using (TestHostContext hc = new TestHostContext(this))
            {
                Tracing trace = hc.GetTrace();

                // Arrange.
                int expected = 123;
                int actual = expected;

                // Act/Assert.
                ArgUtil.Equal(expected: expected, actual: actual, name: "Some parameter");
            }
        }

        [Fact]
        [Trait("Level", "L0")]
        [Trait("Category", "Common")]
        public void Equal_ThrowsWhenActualObjectIsNull()
        {
            using (TestHostContext hc = new TestHostContext(this))
            {
                Tracing trace = hc.GetTrace();

                // Arrange.
                object expected = new object();
                object actual = null;

                // Act/Assert.
                Assert.Throws<ArgumentOutOfRangeException>(() =>
                {
                    ArgUtil.Equal(expected: expected, actual: actual, name: "Some parameter");
                });
            }
        }

        [Fact]
        [Trait("Level", "L0")]
        [Trait("Category", "Common")]
        public void Equal_ThrowsWhenExpectedObjectIsNull()
        {
            using (TestHostContext hc = new TestHostContext(this))
            {
                Tracing trace = hc.GetTrace();

                // Arrange.
                object expected = null;
                object actual = new object();

                // Act/Assert.
                Assert.Throws<ArgumentOutOfRangeException>(() =>
                {
                    ArgUtil.Equal(expected: expected, actual: actual, name: "Some parameter");
                });
            }
        }

        [Fact]
        [Trait("Level", "L0")]
        [Trait("Category", "Common")]
        public void Equal_ThrowsWhenObjectsAreNotEqual()
        {
            using (TestHostContext hc = new TestHostContext(this))
            {
                Tracing trace = hc.GetTrace();

                // Arrange.
                object expected = new object();
                object actual = new object();

                // Act/Assert.
                Assert.Throws<ArgumentOutOfRangeException>(() =>
                {
                    ArgUtil.Equal(expected: expected, actual: actual, name: "Some parameter");
                });
            }
        }

        [Fact]
        [Trait("Level", "L0")]
        [Trait("Category", "Common")]
        public void Equal_ThrowsWhenStructsAreNotEqual()
        {
            using (TestHostContext hc = new TestHostContext(this))
            {
                Tracing trace = hc.GetTrace();

                // Arrange.
                int expected = 123;
                int actual = 456;

                // Act/Assert.
                Assert.Throws<ArgumentOutOfRangeException>(() =>
                {
                    ArgUtil.Equal(expected: expected, actual: actual, name: "Some parameter");
                });
            }
        }
    }
}


text:
package net.ensode.websocketjavaclient;

import javax.swing.JTextArea;

public class WebSocketJavaClientFrame extends javax.swing.JFrame {

    private final WebSocketClient webSocketClient;

    /**
     * Creates new form WebSocketJavaClientFrame
     */
    public WebSocketJavaClientFrame() {
        initComponents();
        webSocketClient = new WebSocketClient(this);
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        jLabel1 = new javax.swing.JLabel();
        userNameTextField = new javax.swing.JTextField();
        jLabel2 = new javax.swing.JLabel();
        jScrollPane1 = new javax.swing.JScrollPane();
        chatWindowTextArea = new javax.swing.JTextArea();
        jLabel3 = new javax.swing.JLabel();
        chatTextField = new javax.swing.JTextField();
        sendButton = new javax.swing.JButton();
        userNameButton = new javax.swing.JButton();
        instrLabel = new javax.swing.JLabel();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Java WebSocket Client");

        jLabel1.setText("User Name");

        jLabel2.setText("Chat Window");

        chatWindowTextArea.setEditable(false);
        chatWindowTextArea.setColumns(20);
        chatWindowTextArea.setRows(5);
        jScrollPane1.setViewportView(chatWindowTextArea);

        jLabel3.setText("Type Something Here");

        chatTextField.setEditable(false);

        sendButton.setText("Send");
        sendButton.setEnabled(false);
        sendButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                sendButtonActionPerformed(evt);
            }
        });

        userNameButton.setText("Set User Name");
        userNameButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                userNameButtonActionPerformed(evt);
            }
        });

        instrLabel.setText("Enter a user name and click \"Set User Name\" to begin.");

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createSequentialGroup()
                        .addGap(54, 54, 54)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                            .addComponent(jLabel2)
                            .addComponent(jLabel1))
                        .addGap(18, 18, 18)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                            .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addGroup(layout.createSequentialGroup()
                                .addComponent(userNameTextField, javax.swing.GroupLayout.PREFERRED_SIZE, 121, javax.swing.GroupLayout.PREFERRED_SIZE)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addComponent(userNameButton)))
                        .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                            .addGroup(layout.createSequentialGroup()
                                .addGap(0, 0, Short.MAX_VALUE)
                                .addComponent(instrLabel, javax.swing.GroupLayout.PREFERRED_SIZE, 356, javax.swing.GroupLayout.PREFERRED_SIZE))
                            .addGroup(layout.createSequentialGroup()
                                .addComponent(jLabel3)
                                .addGap(18, 18, 18)
                                .addComponent(chatTextField, javax.swing.GroupLayout.DEFAULT_SIZE, 225, Short.MAX_VALUE)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                                .addComponent(sendButton)))
                        .addGap(51, 51, 51))))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(instrLabel)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 12, Short.MAX_VALUE)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(userNameTextField, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jLabel1)
                    .addComponent(userNameButton))
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createSequentialGroup()
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                    .addGroup(layout.createSequentialGroup()
                        .addGap(33, 33, 33)
                        .addComponent(jLabel2)))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jLabel3)
                    .addComponent(chatTextField, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(sendButton))
                .addContainerGap())
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents

    private void userNameButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_userNameButtonActionPerformed
        if (userNameTextField.getText() != null && userNameTextField.getText().trim().length() != 0) {
            webSocketClient.setUserName(userNameTextField.getText());
            userNameTextField.setEditable(false);
            userNameButton.setEnabled(false);
            chatTextField.setEditable(true);
            sendButton.setEnabled(true);
            chatTextField.requestFocus();
        }
    }//GEN-LAST:event_userNameButtonActionPerformed

    private void sendButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_sendButtonActionPerformed
        webSocketClient.sendMessage(chatTextField.getText());
    }//GEN-LAST:event_sendButtonActionPerformed

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Set the Nimbus look and feel */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
         */
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(WebSocketJavaClientFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(WebSocketJavaClientFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(WebSocketJavaClientFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(WebSocketJavaClientFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>

        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new WebSocketJavaClientFrame().setVisible(true);
            }
        });
    }

    public JTextArea getChatWindowTextArea() {
        return chatWindowTextArea;
    }

    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JTextField chatTextField;
    private javax.swing.JTextArea chatWindowTextArea;
    private javax.swing.JLabel instrLabel;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JButton sendButton;
    private javax.swing.JButton userNameButton;
    private javax.swing.JTextField userNameTextField;
    // End of variables declaration//GEN-END:variables
}