text:
*Credit: @rwjblue's [twiddle](https://gist.github.com/rwjblue/2d7246875098d0dbb4a4)*

Demo: http://ember-twiddle.com/2d7246875098d0dbb4a4

This addon provides a simple one way input that sends an `update` action when it is updated, and can be used like any other input.

```hbs
  {{one-way-input
      value=currentValue
      update=(action (mut currentValue))
      onenter=(action "commit")
      onescape=(action "escape")
  }}
```

The input can also be used as a checkbox:

```hbs
  {{one-way-input
      type="checkbox"
      checked=currentValue
      update=(action (mut currentValue))
  }}
```

The component's `KEY_EVENTS` attribute can be overwritten to provide custom handlers for various keycodes on the `keyUp` event.

```js
KEY_EVENTS: {
  '13': 'onenter',
  '27': 'onescape'
}
```

This means that the `onenter` and `onescape` actions will fire if their corresponding key codes are received in the `keyUp` event.

## Why?

With Glimmer landing in 1.13.x, native `<input>` elements can now be used in your apps, without the two way binding semantics of the `{{input}}` helper. Shifting to one way bindings ("data down, actions up") makes your app easier to reason about and debug, and is generally the idiomatic way of building Ember apps going forward.

Unfortunately, there is a small gotcha with using a native input like so:

```hbs
<input
  value={{currentValue}}
  oninput={{action (mut currentValue) value="target.value"}}
>
```

In the following [demo](http://jsbin.com/juxedi/edit?output), move your cursor to a character in the middle of the value, and attempt to input new text. You will notice that your cursor immediately jumps to the end of the string, which is entirely unintuitive and annoying.

![](https://i.imgur.com/D0pReSs.jpg)

This addon fixes the cursor jumping issue by using [`readDOMAttr`](http://emberjs.com/api/classes/Ember._MetamorphView.html#method_readDOMAttr), which provides a way to read an element's attribute and update the last value Ember knows about at the same time. This makes setting an attribute idempotent.

## Compatibility

This addon will work on Ember versions `1.13.x` and up.

## Installation

* `git clone` this repository
* `npm install`
* `bower install`

## Running

* `ember server`
* Visit your app at http://localhost:4200.

## Running Tests

* `ember test`
* `ember test --server`

## Building

* `ember build`

For more information on using ember-cli, visit [http://www.ember-cli.com/](http://www.ember-cli.com/).

## Legal

[DockYard](http://dockyard.com/ember-consulting), Inc © 2015

[@dockyard](http://twitter.com/dockyard)

[Licensed under the MIT license](http://www.opensource.org/licenses/mit-license.php)


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Cladonia pseudodidyma Asahina

### Remarks
null

redpajama_set_name: RedPajamaGithub


text:
require_relative 'my_docker_rake/version'
require_relative 'my_docker_rake/utilities'


text:
<?php

namespace Zindex\SiteBuilder\UI;

use Opis\Colibri\ModuleInstaller;
use function Opis\Colibri\Functions\app;

class Installer extends ModuleInstaller
{
    /**
     * @inheritDoc
     */
    public function enable()
    {
        $collector = app()->getCollector();
        $collector->register(Collector\UICollector::NAME, Collector\UICollector::class,
            'Collects UI entries');
    }

    /**
     * @inheritDoc
     */
    public function disable()
    {
        $collector = app()->getCollector();
        $collector->unregister(Collector\UICollector::NAME);
    }

}


text:
<?php

namespace Mage\Adminhtml\Test\Handler\Store;

use Magento\Mtf\Fixture\FixtureInterface;
use Magento\Mtf\Handler\Curl as AbstractCurl;
use Magento\Mtf\Util\Protocol\CurlInterface;
use Magento\Mtf\Util\Protocol\CurlTransport;
use Magento\Mtf\Util\Protocol\CurlTransport\BackendDecorator;

/**
 * Curl handler for creating Store view.
 */
class Curl extends AbstractCurl implements StoreInterface
{
    /**
     * Url for saving data.
     *
     * @var string
     */
    protected $saveUrl = 'system_store/save/';

    /**
     * Mapping values for data.
     *
     * @var array
     */
    protected $mappingData = [
        'group_id' => [
            'Main Website Store' => 1,
        ],
        'is_active' => [
            'Enabled' => 1,
            'Disabled' => 0,
        ],
    ];

    /**
     * POST request for creating store.
     *
     * @param FixtureInterface|null $fixture [optional]
     * @return array
     * @throws \Exception
     */
    public function persist(FixtureInterface $fixture = null)
    {
        $data = $this->prepareData($fixture);
        $url = $_ENV['app_backend_url'] . $this->saveUrl;
        $curl = new BackendDecorator(new CurlTransport(), $this->_configuration);
        $curl->write($url, $data);
        $response = $curl->read();
        $curl->close();
        if (!strpos($response, 'class="success-msg"')) {
            throw new \Exception("Store View entity creating by curl handler was not successful! Response: $response");
        }

        return ['store_id' => $this->getStoreId($fixture->getName())];
    }

    /**
     * Prepare data from text to values.
     *
     * @param FixtureInterface $fixture
     * @return array
     */
    protected function prepareData(FixtureInterface $fixture)
    {
        $data = [
            'store' => $this->replaceMappingData($fixture->getData()),
            'store_action' => 'add',
            'store_type' => 'store',
        ];
        $data['store']['group_id'] = $fixture->getDataFieldConfig('group_id')['source']->getStoreGroup()->getGroupId();
        $data['store']['store_id'] = isset($data['store']['store_id']) ? $data['store']['store_id'] : '';

        return $data;
    }

    /**
     * Get Store id by name after creating Store.
     *
     * @param string $name
     * @return int|null
     * @throws \Exception
     */
    protected function getStoreId($name)
    {
        //Set pager limit to 2000 in order to find created store view by name
        $url = $_ENV['app_backend_url'] . 'system_store/index/sort/store_title/dir/asc/limit/2000';
        $curl = new BackendDecorator(new CurlTransport(), $this->_configuration);
        $curl->addOption(CURLOPT_HEADER, 1);
        $curl->write($url);
        $response = $curl->read();
        preg_match('@.*store_id/(\d+).*' . $name . '@siu', $response, $matches);
        if (empty($matches)) {
            throw new \Exception('Cannot find store id');
        }

        return empty($matches[1]) ? null : $matches[1];
    }
}


text:
import {join} from 'path';
import {ScriptTarget, ModuleKind, NewLineKind} from 'typescript';
import {uglifyJsFile} from './minify-sources';
import {createRollupBundle} from './rollup-helpers';
import {remapSourcemap} from './sourcemap-remap';
import {transpileFile} from './typescript-transpile';
import {buildConfig} from './build-config';

/** Directory where all bundles will be created in. */
const bundlesDir = join(buildConfig.outputDir, 'bundles');

/** Builds the bundles for the specified package. */
export async function buildPackageBundles(entryFile: string, packageName: string) {
  const moduleName = `ng.${packageName}`;

  // List of paths to the package bundles.
  const fesm2015File = join(bundlesDir, `${packageName}.js`);
  const fesm2014File = join(bundlesDir, `${packageName}.es5.js`);
  const umdFile = join(bundlesDir, `${packageName}.umd.js`);
  const umdMinFile = join(bundlesDir, `${packageName}.umd.min.js`);

  // Build FESM-2015 bundle file.
  await createRollupBundle({
    moduleName: moduleName,
    entry: entryFile,
    dest: fesm2015File,
    format: 'es',
  });

  await remapSourcemap(fesm2015File);

  // Downlevel FESM-2015 file to ES5.
  transpileFile(fesm2015File, fesm2014File, {
    importHelpers: true,
    target: ScriptTarget.ES5,
    module: ModuleKind.ES2015,
    allowJs: true,
    newLine: NewLineKind.LineFeed
  });

  await remapSourcemap(fesm2014File);

  // Create UMD bundle of FESM-2014 output.
  await createRollupBundle({
    moduleName: moduleName,
    entry: fesm2014File,
    dest: umdFile,
    format: 'umd'
  });

  await remapSourcemap(umdFile);

  // Create a minified UMD bundle using UglifyJS
  uglifyJsFile(umdFile, umdMinFile);

  await remapSourcemap(umdMinFile);
}


text:
using System;

using Gdk;

using FSpot.Utils;

namespace FSpot.Core
{
	public class Tag : DbItem, IComparable<Tag>, IDisposable
	{
		public string Name { get; set; }
		public int Popularity { get; set; }
		public int SortPriority { get; set; }
		// Icon.  If ThemeIconName is not null, then we save the name of the icon instead
		// of the actual icon data.
		public string ThemeIconName { get; set; }
		public bool IconWasCleared { get; set; }
		bool disposed;

		Category category;
		public Category Category {
			get { return category; }
			set {
				if (Category != null)
					Category.RemoveChild (this);

				category = value;
				if (category != null)
					category.AddChild (this);
			}
		}

		Pixbuf icon;
		public Pixbuf Icon {
			get {
				if (icon == null && ThemeIconName != null) {
					cached_icon_size = IconSize.Hidden;
					icon = GtkUtil.TryLoadIcon (Global.IconTheme, ThemeIconName, 48, (Gtk.IconLookupFlags)0);
				}
				return icon;
			}
			set {
				ThemeIconName = null;
				if (icon != null)
					icon.Dispose ();
				icon = value;
				cached_icon_size = IconSize.Hidden;
				IconWasCleared = value == null;
			}
		}

		public enum IconSize {
			Hidden = 0,
			Small = 16,
			Medium = 24,
			Large = 48
		};

		static IconSize tag_icon_size = IconSize.Large;
		public static IconSize TagIconSize {
			get { return tag_icon_size; }
			set { tag_icon_size = value; }
		}

		Pixbuf cached_icon;
		IconSize cached_icon_size = IconSize.Hidden;

		// We can use a SizedIcon everywhere we were using an Icon
		public Pixbuf SizedIcon {
			get {
				if (tag_icon_size == IconSize.Hidden) //Hidden
					return null;
				if (tag_icon_size == cached_icon_size)
					return cached_icon;
				if (ThemeIconName != null) { //Theme icon
					if (cached_icon != null)
						cached_icon.Dispose ();
					try {
						cached_icon = GtkUtil.TryLoadIcon (Global.IconTheme, ThemeIconName, (int)tag_icon_size, (Gtk.IconLookupFlags)0);

						if (Math.Max (cached_icon.Width, cached_icon.Height) <= (int)tag_icon_size)
							return cached_icon;
					} catch (Exception) {
						Console.WriteLine ("missing theme icon: {0}", ThemeIconName);
						return null;
					}
				}
				if (Icon == null)
					return null;

				if (Math.Max (Icon.Width, Icon.Height) >= (int)tag_icon_size) { //Don't upscale
					if (cached_icon != null)
						cached_icon.Dispose ();
					cached_icon = Icon.ScaleSimple ((int)tag_icon_size, (int)tag_icon_size, InterpType.Bilinear);
					cached_icon_size = tag_icon_size;
					return cached_icon;
				}
				return Icon;
			}
		}

		// FIXME: Why does this ctor take one of its derived classes as a parameter?
		// You are not supposed to invoke these constructors outside of the TagStore class.
		public Tag (Category category, uint id, string name) : base (id)
		{
			Category = category;
			Name = name;
			Popularity = 0;
			IconWasCleared = false;
		}

		// IComparer
		public int CompareTo (Tag tag)
		{
			if (tag == null)
				throw new ArgumentNullException ("tag");

			if (Category == tag.Category) {
				if (SortPriority == tag.SortPriority)
					return Name.CompareTo (tag.Name);
				return SortPriority - tag.SortPriority;
			}
			return Category.CompareTo (tag.Category);
		}

		public bool IsAncestorOf (Tag tag)
		{
			if (tag == null)
				throw new ArgumentNullException ("tag");

			for (Category parent = tag.Category; parent != null; parent = parent.Category) {
				if (parent == this)
					return true;
			}

			return false;
		}

		public void Dispose()
		{
			Dispose(true);
			System.GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposed)
				return;
			disposed = true;

			if (disposing) {
				// free managed resources
				if (icon != null) {
					icon.Dispose ();
					icon = null;
				}
				if (cached_icon != null) {
					cached_icon.Dispose ();
					cached_icon = null;
				}
			}
			// free unmanaged resources
		}
	}
}


text:
import React from 'react';
import { Image, requireNativeComponent } from 'react-native';
import { meetOrSliceTypes, alignEnum } from '../lib/extract/extractViewBox';
import extractProps, { propsAndStyles } from '../lib/extract/extractProps';
import Shape from './Shape';

const spacesRegExp = /\s+/;

export default class SvgImage extends Shape {
  static displayName = 'Image';

  static defaultProps = {
    x: 0,
    y: 0,
    width: 0,
    height: 0,
    preserveAspectRatio: 'xMidYMid meet',
  };

  render() {
    const { props } = this;
    const {
      preserveAspectRatio,
      x,
      y,
      width,
      height,
      xlinkHref,
      href = xlinkHref,
    } = props;
    const modes = preserveAspectRatio.trim().split(spacesRegExp);
    return (
      <RNSVGImage
        ref={this.refMethod}
        {...extractProps({ ...propsAndStyles(props), x: null, y: null }, this)}
        x={x}
        y={y}
        width={width}
        height={height}
        meetOrSlice={meetOrSliceTypes[modes[1]] || 0}
        align={alignEnum[modes[0]] || 'xMidYMid'}
        src={Image.resolveAssetSource(href)}
      />
    );
  }
}

const RNSVGImage = requireNativeComponent('RNSVGImage');


text:
name: Trigger Happy
abbreviation: TR
type: Bad
summary: Tank can't stop firing.
---

The Trigger Happy (TR) flag causes all of a tank's shots to be fired as fast as they are reloaded, leaving a tank without any ammo.

## Tactics

Trigger Happy requires appropriate timing as well as being able to accurately aim shots to counter its effects. Due to all shots being fired immediately, tanks have little control of where to aim the shots being fired. This can accidentally lead to team kills or ricochets causing self-kills.


text:
"use strict";

const nodeContextLookup = require("../nodeContextLookup");
const path = require("path");
const postcss = require("postcss");
const postcssImport = require("postcss-import");

it("nodeContextLookup checking media context", () => {
  const testLookup = nodeContextLookup();

  return postcss([postcssImport()])
    .process("@import 'fixtures/one.css'; @import 'fixtures/two.css';", {
      from: path.join(__dirname, "fake.css")
    })
    .then(result => {
      const rulesBySelector = {};
      result.root.walkRules(rule => {
        rulesBySelector[rule.selector] = rule;
      });

      // a-d are in one file; e-h in another
      expect(
        testLookup.getContext(rulesBySelector.a, rulesBySelector.a.parent)
      ).toBe(
        testLookup.getContext(rulesBySelector.b, rulesBySelector.b.parent)
      );

      expect(
        testLookup.getContext(rulesBySelector.a, rulesBySelector.a.parent)
      ).not.toBe(
        testLookup.getContext(rulesBySelector.c, rulesBySelector.c.parent)
      );

      expect(
        testLookup.getContext(rulesBySelector.a, rulesBySelector.a.parent)
      ).not.toBe(
        testLookup.getContext(rulesBySelector.e, rulesBySelector.e.parent)
      );

      expect(
        testLookup.getContext(rulesBySelector.c, rulesBySelector.c.parent)
      ).toBe(
        testLookup.getContext(rulesBySelector.d, rulesBySelector.d.parent)
      );

      expect(
        testLookup.getContext(rulesBySelector.c, rulesBySelector.c.parent)
      ).not.toBe(
        testLookup.getContext(rulesBySelector.g, rulesBySelector.g.parent)
      );

      expect(
        testLookup.getContext(rulesBySelector.e, rulesBySelector.e.parent)
      ).toBe(
        testLookup.getContext(rulesBySelector.f, rulesBySelector.f.parent)
      );

      expect(
        testLookup.getContext(rulesBySelector.f, rulesBySelector.f.parent)
      ).not.toBe(
        testLookup.getContext(rulesBySelector.g, rulesBySelector.g.parent)
      );

      expect(
        testLookup.getContext(rulesBySelector.g, rulesBySelector.g.parent)
      ).toBe(
        testLookup.getContext(rulesBySelector.h, rulesBySelector.h.parent)
      );
    })
    .catch(err => console.log(err.stack)); // eslint-disable-line
});


text:
 <?php echo Yii::t("need","HELPERS",null,Yii::app()->controller->module->id); ?>

				<?php
					$needId = $id;
				?>

					<?php
					$nbValidate=0;
					$nbToConfirm=0;
					if(!empty($helpers)){
						$i=0;
						foreach ($helpers as $id => $val){
							if($val["isValidated"] == 1){ ?>

									<a class="lbh" href="#person.detail.id.<?php echo (string)$val["_id"] ?>" title="validated">
									<?php if(isset($val["imagePath"])) { ?>
										<img width="50" height="50" alt="image" class="img-circle" src="<?php echo Yii::app()->createUrl('/'.$this->module->id.'/document/resized/50x50'.$val['imagePath']) ?>">
								<?php } else{
									echo "";
								} ?>

							<?php
								$nbValidate++;
							}
							else{ ?>
								<div class="col-md-3 col-xs-4 center padding-10 helperBoxToValidate helperBox<?php echo (string)$val["_id"] ?>">

									<a class="lbh" href="#person.detail.id.<?php echo (string)$val["_id"] ?>" title="wait for validation">
									<?php if(isset($val["imagePath"])) { ?>
									<img width="50" height="50" alt="image" class="img-circle grayscale" src="<?php echo Yii::app()->createUrl('/'.$this->module->id.'/document/resized/50x50'.$val['imagePath']) ?>">
									<?php } else{
												echo "";
											} ?>

									<a href="javascript:;" class="acceptHelp" data-id="<?php echo (string)$val["_id"]; ?>" data-name="<?php echo $val["name"]; ?>">

							<?php
								$nbToConfirm++;
							}
							$i++;
						}
						if($i != $quantity){
							for ($i;$i<$quantity;$i++){ ?>

 ?

							<?php }
						}
					}
					else{
						for ($i=0; $i<$quantity;$i++){ ?>

 ?

					<?php }
						} ?>

						<?php echo $nbValidate; ?> / <?php echo $quantity;?> <?php echo Yii::t("need","HELPER",null,Yii::app()->controller->module->id); if ($quantity > 1) echo "S" ?>

					<?php if($quantity==($nbToConfirm+$nbValidate)){ ?>

 <?php echo Yii::t("need","Need has enough helpers !!",null,Yii::app()->controller->module->id); ?>

					<?php }else{ ?>

 <?php echo Yii::t("need","Contribute to the project ansering  to this need !!",null,Yii::app()->controller->module->id); ?>

							 <?php echo Yii::t("need","Involve me",null,Yii::app()->controller->module->id); ?>

					<?php } ?>


text:
*Todo*

Want to contribute this page? Edit this file and submit a Pull Request!


text:
import { Reflective, Types, getClassType } from "tsruntime";

@Reflective
class TestClass extends Array<string> {
  "str": string;
  "str-str": string;
  42: string;
  get computed() {
    return "string";
  }
  [Symbol.toPrimitive]() {
    return 23;
  }
  method() {
    return "asd";
  }
}

@Reflective
class TestClass2 extends TestClass {
  newProp!: string;
}

describe("Class Decoration", () => {
  it("should decorate TestClass", () => {
    const type = getClassType(TestClass)

    expect(type).toMatchObject({
      name: "TestClass",
      kind: Types.TypeKind.Class,
      extends: {
        kind: Types.TypeKind.Reference,
        type: Array,
        arguments: [{ kind: Types.TypeKind.String }]
      },
      properties: {
        str: { kind: Types.TypeKind.String },
        "str-str": { kind: Types.TypeKind.String },
        42: { kind: Types.TypeKind.String }
      },
      constructors: {},
    });
  });

  it("should decorate TestClass2", () => {
    const type = getClassType(TestClass2)

    expect(type).toMatchObject({
      name: "TestClass2",
      kind: Types.TypeKind.Class,
      extends: {
        kind: Types.TypeKind.Reference,
        type: TestClass,
        arguments: []
      },
      properties: {
        newProp: { kind: Types.TypeKind.String },
      },
      constructors: {},
    });
  });

});


text:
package org.frostbite.karren.Interactions;

public class InteractionTemplate {
    private String template;
    private String templateType;

    public InteractionTemplate(String template, String templateType){
        this.template = template;
        this.templateType = templateType;
    }

    public String getTemplate() {
        return template;
    }

    public void setTemplate(String template) {
        this.template = template;
    }

    public String getTemplateType() {
        return templateType;
    }

    public void setTemplateType(String templateType) {
        this.templateType = templateType;
    }

}


text:
package org.marekasf.troughput.histogram;

import java.util.ArrayList;

/**
 * The HistogramDataNode stores the histogram data for a range of values.
 * It knows the minimum and maximum values for which it counts the number of instances.
 * When the count exceeds the allowed limit it splits itself in two, increasing the
 * histogram resolution for this range.
 * @author Jorge Handl
 */

public class HistogramDataNode extends HistogramNode {

	private static final long serialVersionUID = -1L;

   // Attributes of a data node.
	private Cell cell = new Cell();

    /**
	 * Creates an empty data node.
     */
    public HistogramDataNode () {
        reset();
    }

    /**
     * Creates a data node for the given range with the given instance count.
     * @param count the number of data instances in the given range.
     * @param minValue the start of the range of counted values.
     * @param maxValue the end of the range of counted values.
     */
    public HistogramDataNode (long count, float minValue, float maxValue) {
        reset();
        cell.count = count;
        cell.minValue = minValue;
        cell.maxValue = maxValue;
    }

    /**
     * Clears the data node.
     */
    public void reset () {
        cell.count = 0;
        cell.minValue = Float.MAX_VALUE;
        cell.maxValue = -Float.MAX_VALUE;
    }

    /**
     * Adds a value to the data node.

     * If the value falls inside of the nodes' range and the count does not exceed the imposed limit, it simply increments the count.

     * If the value falls outside of the nodes' range, it expands the range.

     * If the count exceeds the limit, it splits in two assuming uniform distribution inside the node.

     * If the value falls outside of the nodes' range AND the count exceeds the limit, it creates a new node for that value.
     * @param root a reference to the adaptive histogram instance that uses this structure.
     * @param value the value for which the count is to be incremented.
     * @return A reference to itself if no structural change happened, or a reference to the new fork node if this node was split.
     */
    public HistogramNode addValue (AdaptiveHistogram root, float value) {
        // "self" is what is returned to the caller. If this node needs to be replaced by a fork node,
        // this variable will hold the new fork node and it will be returned to the caller.
        // Otherwise, the node returned will be this, in which case nothing changes.
        HistogramNode self = this;
        if (value >= cell.minValue && value <= cell.maxValue) {  // the value falls within this nodes' range
            if (cell.count < root.getCountPerNodeLimit()  // there is enough room in this node for the new value
                    || cell.minValue == cell.maxValue) {  // or the node defines a zero-width range so it can't be split
            	cell.count++;
            } else {  // not enough room, distribute the value count among the new nodes, assuming uniform distribution
                float splitValue = (cell.minValue + cell.maxValue) / 2;
                long rightCount = cell.count / 2;
                long leftCount = rightCount;
                boolean countWasOdd = (leftCount + rightCount < cell.count);
                // assign the new value to the corresponding side. If the count is odd, add the extra item to the other side to keep balance
                if (value > splitValue) {
                    rightCount++;
                    leftCount += (countWasOdd?1:0);
                } else {
                    leftCount++;
                    rightCount += (countWasOdd?1:0);
                }
                // create a new subtree that will replace this node
                HistogramNode leftNode = new HistogramDataNode(leftCount, cell.minValue, splitValue);
                HistogramNode rightNode = new HistogramDataNode(rightCount, splitValue, cell.maxValue);
                self = new HistogramForkNode(splitValue, leftNode, rightNode);
            }
        } else {  // the value falls outside of this nodes' range
            if (cell.count < root.getCountPerNodeLimit()) {  // there is enough room in this node for the new value
            	cell.count++;
                // extend the range of this node, assuming that the tree structure above correctly directed
                // the given value to this node and therefore it lies at one of the borders of the tree.
				if (value < cell.minValue)
				{
					cell.minValue = value;
				}
				if (value > cell.maxValue)
				{
					cell.maxValue = value;
				}
            } else {  // not enough room, create a new sibling node for the new value and put both under a new fork node
                if (value < cell.minValue) {
                	cell.minValue = Math.min(cell.minValue, (value + cell.maxValue) / 2);
                    self = new HistogramForkNode(cell.minValue, new HistogramDataNode(1,value,cell.minValue), this);
                } else {
                	cell.maxValue = Math.max(cell.maxValue, (cell.minValue + value) / 2);
                    self = new HistogramForkNode(cell.maxValue, this, new HistogramDataNode(1,cell.maxValue,value));
                }
            }
        }
        return self;
    }

    /**
     * Returns the number of data points stored in the same bucket as a given value.
     * @param value the reference data point.
     * @return the number of data points stored in the same bucket as the reference point.
     */
    public long getCount (float value) {
        long res = 0;
        if (value >= cell.minValue && value <= cell.maxValue) {
            res = cell.count;
        }
        return res;
    }

    /**
     * Returns the cumulative density function for a given data point.
     * @param value the reference data point.
     * @return the cumulative density function for the reference point.
     */
    public long getAccumCount (float value) {
        long res = 0;
        if (value >= cell.minValue) {
            res = cell.count;
        }
        return res;
    }

    // Linear interpolation for float values.
    private float interpolate (float x0, float y0, float x1, float y1, float x) {
        return y0+((x-x0)*(y1-y0))/(x1-x0);
    }

    /**
     * Returns the data point where the running cumulative count reaches the target cumulative count.
     * It uses linear interpolation over the range of the node to get a better estimate of the true value.
     * @param accumCount an array containing:

     *      - accumCount[0] the running cumulative count.

     *      - accumCount[1] the target cumulative count.
     * @return the data point where the running cumulative count reaches the target cumulative count.
     */
    public Float getValueForAccumCount (long[] accumCount) {
        Float res = null;
        long runningAccumCount = accumCount[0];
        long targetAccumCount = accumCount[1];
        if (runningAccumCount <= targetAccumCount && runningAccumCount + cell.count >= targetAccumCount) {
            float val = interpolate((float)runningAccumCount, cell.minValue, (float)(runningAccumCount + cell.count), cell.maxValue, (float)targetAccumCount);
            res = new Float(val);
        }
        accumCount[0] += cell.count;
        return res;
    }

    /**
     * Applies a convertion function to the values stored in the histogram.
     * @param valueConversion a class that defines a function to convert the value.
     */
    public void apply (AdaptiveHistogram.ValueConversion valueConversion) {
    	cell.minValue = valueConversion.convertValue(cell.minValue);
    	cell.maxValue = valueConversion.convertValue(cell.maxValue);
    }

    /**
     * Prints this nodes' data with a margin depending on the level of the node in the tree.
     * @param level the level of this node in the tree.
     */
    public void show (int level) {
        margin(level);
        System.out.println("Data: " + cell.count + " ("+cell.minValue+","+cell.maxValue+")");
    }

    /**
     * Build the table representing the histogram data adding this node's cell to it.
     */
    public void toTable (ArrayList<Cell> table) {
    	table.add(cell);
    }

}


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

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Class com.smartsheet.api.models.ProfileImage (Smartsheet Java SDK 2.146.0 API)</title>
<meta name="date" content="2021-11-12">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Uses of Class
com.smartsheet.api.models.ProfileImage

Packages that use ProfileImage

Package
Description

com.smartsheet.api.models

Uses of ProfileImage in com.smartsheet.api.models

Methods in com.smartsheet.api.models that return ProfileImage

Modifier and Type
Method and Description

ProfileImage
UserModel.getProfileImage()

Gets the user's profile image

ProfileImage
ProfileImage.setHeight(Long height)

sets the width (in pixels) of the image

ProfileImage
ProfileImage.setImageId(String id)

sets the image ID

ProfileImage
ProfileImage.setWidth(Long width)

sets the width (in pixels)

Methods in com.smartsheet.api.models with parameters of type ProfileImage

Modifier and Type
Method and Description

UserModel
UserModel.setProfileImage(ProfileImage profileImage)

Sets the user's profile image

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Copyright © 2014–2021 Smartsheet. All rights reserved.


text:
namespace Cosmetics.Engine
{
    using System.Collections.Generic;

    using Cosmetics.Common;
    using Cosmetics.Contracts;
    using Cosmetics.Products;

    public class CosmeticsFactory : ICosmeticsFactory
    {
        public ICategory CreateCategory(string name)
        {
            return new Category(name);
        }

        public IShampoo CreateShampoo(string name, string brand, decimal price, GenderType gender, uint milliliters, UsageType usage)
        {
            // TODO: create shampoo
        }

        public IToothpaste CreateToothpaste(string name, string brand, decimal price, GenderType gender, IList<string> ingredients)
        {
            // TODO: create toothpaste
        }

        public IShoppingCart ShoppingCart()
        {
            // TODO: create shopping cart
        }
    }
}


text:
__author__ = "Liu Fei"
__github__ = "http://github.com/lfblogs"
__all__ = [
    "select",
    "execute"
]

"""
"""

import asyncio
import logging

logging.basicConfig(level=logging.INFO)

@asyncio.coroutine
def select(sql, args, size=None):
    logging.info('SQL: {}'.format(sql))
    global __pool
    with (yield from __pool) as conn:
        cursor = yield from conn.cursor()
        yield from cursor.execute(sql.replace('?', '%s'), args or ())
        value = (yield from cursor.fetchmany(size)) if size else (yield from cursor.fetchall())
        yield from cursor.close()
        logging.info('rows return: {}'.format(value))
        return value

@asyncio.coroutine
def execute(sql, args, autocommit=True):
    logging.info('SQL: {}'.format(sql))
    with (yield from __pool) as conn:
        if not autocommit:
            yield from conn.begin()
        try:
            cursor = yield from conn.cursor()
            yield from cursor.execute(sql.replace('?', '%s'), args)
            affected = cursor.rowcount
            yield from cursor.close()
            if not autocommit:
                yield from conn.commit()
        except BaseException as e:
            if not autocommit:
                yield from conn.rollback()
            raise
        return affected


text:
<?php
namespace Upwork\API\Tests\Routers\Organization;

use Upwork\API\Tests\Routers\CommonTestRouter;

require_once __DIR__  . '/../CommonTestRouter.php';

class CompaniesTest extends CommonTestRouter
{
    /**
     * Setup
     */
    public function setUp(): void
    {
        parent::setUp();
    }

    /**
     * @test
     */
    public function testGetList()
    {
        $router = new \Upwork\API\Routers\Organization\Companies($this->_client);
        $response = $router->getList();

        $this->_checkResponse($response);
    }

    /**
     * @test
     */
    public function testGetSpecific()
    {
        $router = new \Upwork\API\Routers\Organization\Companies($this->_client);
        $response = $router->getSpecific('12345');

        $this->_checkResponse($response);
    }

    /**
     * @test
     */
    public function testGetTeams()
    {
        $router = new \Upwork\API\Routers\Organization\Companies($this->_client);
        $response = $router->getTeams('12345');

        $this->_checkResponse($response);
    }

    /**
     * @test
     */
    public function testUsers()
    {
        $router = new \Upwork\API\Routers\Organization\Companies($this->_client);
        $response = $router->getUsers('12345');

        $this->_checkResponse($response);
    }
}


text:
/*	$NetBSD: libdwarf_loclist.c,v 1.2 2014/03/09 16:58:04 christos Exp $	*/

/*-
 * Copyright (c) 2009,2011 Kai Wang
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "_libdwarf.h"

__RCSID("$NetBSD: libdwarf_loclist.c,v 1.2 2014/03/09 16:58:04 christos Exp $");
ELFTC_VCSID("Id: libdwarf_loclist.c 2972 2013-12-23 06:46:04Z kaiwang27 ");

static int
_dwarf_loclist_add_locdesc(Dwarf_Debug dbg, Dwarf_CU cu, Dwarf_Section *ds,
    uint64_t *off, Dwarf_Locdesc **ld, uint64_t *ldlen,
    Dwarf_Unsigned *total_len, Dwarf_Error *error)
{
	uint64_t start, end;
	int i, len, ret;

	if (total_len != NULL)
		*total_len = 0;

	for (i = 0; *off < ds->ds_size; i++) {
		start = dbg->read(ds->ds_data, off, cu->cu_pointer_size);
		end = dbg->read(ds->ds_data, off, cu->cu_pointer_size);
		if (ld != NULL) {
			ld[i]->ld_lopc = start;
			ld[i]->ld_hipc = end;
		}

		if (total_len != NULL)
			*total_len += 2 * cu->cu_pointer_size;

		/* Check if it is the end entry. */
		if (start == 0 && end ==0) {
			i++;
			break;
		}

		/* Check if it is base-select entry. */
		if ((cu->cu_pointer_size == 4 && start == ~0U) ||
		    (cu->cu_pointer_size == 8 && start == ~0ULL))
			continue;

		/* Otherwise it's normal entry. */
		len = dbg->read(ds->ds_data, off, 2);
		if (*off + len > ds->ds_size) {
			DWARF_SET_ERROR(dbg, error,
			    DW_DLE_DEBUG_LOC_SECTION_SHORT);
			return (DW_DLE_DEBUG_LOC_SECTION_SHORT);
		}

		if (total_len != NULL)
			*total_len += len;

		if (ld != NULL) {
			ret = _dwarf_loc_fill_locdesc(dbg, ld[i],
			    ds->ds_data + *off, len, cu->cu_pointer_size,
			    error);
			if (ret != DW_DLE_NONE)
				return (ret);
		}

		*off += len;
	}

	if (ldlen != NULL)
		*ldlen = i;

	return (DW_DLE_NONE);
}

int
_dwarf_loclist_find(Dwarf_Debug dbg, Dwarf_CU cu, uint64_t lloff,
    Dwarf_Loclist *ret_ll, Dwarf_Error *error)
{
	Dwarf_Loclist ll;
	int ret;

	assert(ret_ll != NULL);
	ret = DW_DLE_NONE;

	TAILQ_FOREACH(ll, &dbg->dbg_loclist, ll_next)
		if (ll->ll_offset == lloff)
			break;

	if (ll == NULL)
		ret = _dwarf_loclist_add(dbg, cu, lloff, ret_ll, error);
	else
		*ret_ll = ll;

	return (ret);
}

int
_dwarf_loclist_add(Dwarf_Debug dbg, Dwarf_CU cu, uint64_t lloff,
    Dwarf_Loclist *ret_ll, Dwarf_Error *error)
{
	Dwarf_Section *ds;
	Dwarf_Loclist ll, tll;
	uint64_t ldlen;
	int i, ret;

	ret = DW_DLE_NONE;

	if ((ds = _dwarf_find_section(dbg, ".debug_loc")) == NULL) {
		DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY);
		return (DW_DLE_NO_ENTRY);
	}

	if (lloff >= ds->ds_size) {
		DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY);
		return (DW_DLE_NO_ENTRY);
	}

	if ((ll = malloc(sizeof(struct _Dwarf_Loclist))) == NULL) {
		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
		return (DW_DLE_MEMORY);
	}

	ll->ll_offset = lloff;

	/* Get the number of locdesc the first round. */
	ret = _dwarf_loclist_add_locdesc(dbg, cu, ds, &lloff, NULL, &ldlen,
	    NULL, error);
	if (ret != DW_DLE_NONE)
		goto fail_cleanup;

	/*
	 * Dwarf_Locdesc list memory is allocated in this way (one more level
	 * of indirect) to make the loclist API be compatible with SGI libdwarf.
	 */
	ll->ll_ldlen = ldlen;
	if (ldlen != 0) {
		if ((ll->ll_ldlist = calloc(ldlen, sizeof(Dwarf_Locdesc *))) ==
		    NULL) {
			DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
			ret = DW_DLE_MEMORY;
			goto fail_cleanup;
		}
		for (i = 0; (uint64_t) i < ldlen; i++) {
			if ((ll->ll_ldlist[i] =
			    calloc(1, sizeof(Dwarf_Locdesc))) == NULL) {
				DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
				ret = DW_DLE_MEMORY;
				goto fail_cleanup;
			}
		}
	} else
		ll->ll_ldlist = NULL;

	lloff = ll->ll_offset;

	/* Fill in locdesc. */
	ret = _dwarf_loclist_add_locdesc(dbg, cu, ds, &lloff, ll->ll_ldlist,
	    NULL, &ll->ll_length, error);
	if (ret != DW_DLE_NONE)
		goto fail_cleanup;

	/* Insert to the queue. Sort by offset. */
	TAILQ_FOREACH(tll, &dbg->dbg_loclist, ll_next)
		if (tll->ll_offset > ll->ll_offset) {
			TAILQ_INSERT_BEFORE(tll, ll, ll_next);
			break;
		}

	if (tll == NULL)
		TAILQ_INSERT_TAIL(&dbg->dbg_loclist, ll, ll_next);

	*ret_ll = ll;
	return (DW_DLE_NONE);

fail_cleanup:

	_dwarf_loclist_free(ll);

	return (ret);
}

void
_dwarf_loclist_free(Dwarf_Loclist ll)
{
	int i;

	if (ll == NULL)
		return;

	if (ll->ll_ldlist != NULL) {
		for (i = 0; i < ll->ll_ldlen; i++) {
			if (ll->ll_ldlist[i]->ld_s)
				free(ll->ll_ldlist[i]->ld_s);
			free(ll->ll_ldlist[i]);
		}
		free(ll->ll_ldlist);
	}
	free(ll);
}

void
_dwarf_loclist_cleanup(Dwarf_Debug dbg)
{
	Dwarf_Loclist ll, tll;

	assert(dbg != NULL && dbg->dbg_mode == DW_DLC_READ);

	TAILQ_FOREACH_SAFE(ll, &dbg->dbg_loclist, ll_next, tll) {
		TAILQ_REMOVE(&dbg->dbg_loclist, ll, ll_next);
		_dwarf_loclist_free(ll);
	}
}


text:
Appveyor

WHIP-LRU is a WHIP-protocol-compatible asset cache for [Halcyon][]-based servers using C#, such as [Inworldz][].

For installation and building instructions, please see the [wiki][wiki].

[InWorldz]: http://inworldz.com/
[Halcyon]: https://github.com/InWorldz/halcyon
[wiki]: https://github.com/kf6kjg/WHIP-LRU/wiki

# Supported operating systems
At this time, only the following operating systems are being supported and tested, as I am only one guy on one computer:

* Ubuntu Linux 16.04 and newer

Open source contributions are very welcome - especially as regards testing and correcting for other operating systems.


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

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>trandom</title>
    <link rel="stylesheet" type="text/css" href="csound.css" />
    <meta name="generator" content="DocBook XSL Stylesheets V1.78.1" />
    <link rel="home" href="index.html" title="Manuel de référence canonique de Csound" />
    <link rel="up" href="OpcodesTop.html" title="Opcodes et opérateurs de l'orchestre" />
    <link rel="prev" href="tonex.html" title="tonex" />
    <link rel="next" href="tradsyn.html" title="tradsyn" />

          trandom

          Précédent
          Opcodes et opérateurs de l'orchestre
           Suivant

          trandom

trandom —
     Génère une suite contrôlée de nombres pseudo-aléatoires entre des valeurs
     minimale et maximale en fonction d'un déclencheur.

Description

      Génère au taux-k une suite contrôlée de nombres pseudo-aléatoires entre des
      valeurs minimale et maximale chaque fois que le paramètre de déclenchement
      est différent de 0.

Syntaxe

kout trandom ktrig, kmin, kmax

Exécution

      ktrig -- déclencheur (l'opcode produit un nouveau
      nombre aléatoire chaque fois que cette valeur est différente de 0.

      kmin -- limite inférieure de l'intervalle

      kmax -- limite supérieure de l'intervalle

     trandom est presque identique à l'opcode
     random sauf que
     trandom ne renouvelle sa sortie avec une nouvelle
     valeur aléatoire que si l'argument ktrig est déclenché
     (c-à-d chaque fois qu'il est différent de zéro).

Exemples

      Voici un exemple de l'opcode trandom. Il utilise le fichier
      trandom.csd.

            Exemple 971. Exemple de l'opcode trandom.

Voir les sections Audio en Temps Réel
        et Options de la Ligne de Commande pour plus
        d'information sur l'utilisation des options de la ligne de commande.

<CsoundSynthesizer>
<CsOptions>
; Select audio/midi flags here according to platform
-odac     ;;;realtime audio out
;-iadc    ;;;uncomment -iadc if realtime audio input is needed too
; For Non-realtime ouput leave only the line below:
; -o trandom.wav -W ;;; for file output any platform
</CsOptions>
<CsInstruments>

sr = 44100
ksmps = 32
nchnls = 2
0dbfs  = 1

seed 0				; every run time different values

instr 1

kmin init 0			;random number between 0 and 220
kmax init 220
ktrig = p4
k1   trandom ktrig, kmin, kmax
     printk2 k1			;print when k1 changes
asig poscil .4, 220+k1, 1	;if triggered, add random values to frequency
     outs asig, asig

endin
</CsInstruments>
<CsScore>
f1 0 4096 10 1

i 1 0 2 0	;not triggered
i 1 + 2 1	;triggered
e
</CsScore>
</CsoundSynthesizer>

Voir aussi

      random

Crédits

Ecrit par Gabriel Maldonado.

Nouveau dans Csound 5.06

          Précédent

            Niveau supérieur

           Suivant

          tonex

            Sommaire

           tradsyn


text:
/*!
	@file
	@author		Albert Semenov
	@date		05/2010
*/
/*
	This file is part of MyGUI.

	MyGUI is free software: you can redistribute it and/or modify
	it under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	MyGUI is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License
	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "MyGUI_Precompiled.h"
#include "MyGUI_WidgetInput.h"
#include "MyGUI_Widget.h"

namespace MyGUI
{

	WidgetInput::WidgetInput() :
		mNeedToolTip(false),
		mInheritsPick(false),
		mNeedKeyFocus(false),
		mNeedMouseFocus(true),
		mRootMouseFocus(false),
		mRootKeyFocus(false)
	{
	}

	WidgetInput::~WidgetInput()
	{
	}

	void WidgetInput::setMaskPick(const std::string& _filename)
	{
		if (_filename.empty())
			mOwnMaskPickInfo = MaskPickInfo();
		else if (!mOwnMaskPickInfo.load(_filename))
			MYGUI_LOG(Error, "mask not load '" << _filename << "'");
	}

	void WidgetInput::setMaskPick(const MaskPickInfo& _info)
	{
		mOwnMaskPickInfo = _info;
	}

	bool WidgetInput::isMaskPickInside(const IntPoint& _point, const IntCoord& _coord) const
	{
		return mOwnMaskPickInfo.empty() || mOwnMaskPickInfo.pick(_point, _coord);
	}

	void WidgetInput::_riseMouseLostFocus(Widget* _new)
	{
		onMouseLostFocus(_new);
		eventMouseLostFocus(static_cast<Widget*>(this), _new);
	}

	void WidgetInput::_riseMouseSetFocus(Widget* _old)
	{
		onMouseSetFocus(_old);
		eventMouseSetFocus(static_cast<Widget*>(this), _old);
	}

	void WidgetInput::_riseMouseDrag(int _left, int _top, MouseButton _id)
	{
		onMouseDrag(_left, _top, _id);
		eventMouseDrag(static_cast<Widget*>(this), _left, _top, _id);
	}

	void WidgetInput::_riseMouseMove(int _left, int _top)
	{
		onMouseMove(_left, _top);
		eventMouseMove(static_cast<Widget*>(this), _left, _top);
	}

	void WidgetInput::_riseMouseWheel(int _rel)
	{
		onMouseWheel(_rel);
		eventMouseWheel(static_cast<Widget*>(this), _rel);
	}

	void WidgetInput::_riseMouseButtonPressed(int _left, int _top, MouseButton _id)
	{
		onMouseButtonPressed(_left, _top, _id);
		eventMouseButtonPressed(static_cast<Widget*>(this), _left, _top, _id);
	}

	void WidgetInput::_riseMouseButtonReleased(int _left, int _top, MouseButton _id)
	{
		onMouseButtonReleased(_left, _top, _id);
		eventMouseButtonReleased(static_cast<Widget*>(this), _left, _top, _id);
	}

	void WidgetInput::_riseMouseButtonClick()
	{
		onMouseButtonClick();
		eventMouseButtonClick(static_cast<Widget*>(this));
	}

	void WidgetInput::_riseMouseButtonDoubleClick()
	{
		onMouseButtonDoubleClick();
		eventMouseButtonDoubleClick(static_cast<Widget*>(this));
	}

	void WidgetInput::_riseKeyLostFocus(Widget* _new)
	{
		onKeyLostFocus(_new);
		eventKeyLostFocus(static_cast<Widget*>(this), _new);
	}

	void WidgetInput::_riseKeySetFocus(Widget* _old)
	{
		onKeySetFocus(_old);
		eventKeySetFocus(static_cast<Widget*>(this), _old);
	}

	void WidgetInput::_riseKeyButtonPressed(KeyCode _key, Char _char)
	{
		onKeyButtonPressed(_key, _char);
		eventKeyButtonPressed(static_cast<Widget*>(this), _key, _char);
	}

	void WidgetInput::_riseKeyButtonReleased(KeyCode _key)
	{
		onKeyButtonReleased(_key);
		eventKeyButtonReleased(static_cast<Widget*>(this), _key);
	}

	void WidgetInput::_riseMouseChangeRootFocus(bool _focus)
	{
		onMouseChangeRootFocus(_focus);
		eventRootMouseChangeFocus(static_cast<Widget*>(this), _focus);
	}

	void WidgetInput::_riseKeyChangeRootFocus(bool _focus)
	{
		onKeyChangeRootFocus(_focus);
		eventRootKeyChangeFocus(static_cast<Widget*>(this), _focus);
	}

	void WidgetInput::setNeedToolTip(bool _value)
	{
		mNeedToolTip = _value;
	}

	bool WidgetInput::getNeedToolTip() const
	{
		return mNeedToolTip;
	}

	void WidgetInput::setPointer(const std::string& _value)
	{
		mPointer = _value;
	}

	const std::string& WidgetInput::getPointer() const
	{
		return mPointer;
	}

	void WidgetInput::setNeedKeyFocus(bool _value)
	{
		mNeedKeyFocus = _value;
	}

	bool WidgetInput::getNeedKeyFocus() const
	{
		return mNeedKeyFocus;
	}

	void WidgetInput::setNeedMouseFocus(bool _value)
	{
		mNeedMouseFocus = _value;
	}

	bool WidgetInput::getNeedMouseFocus() const
	{
		return mNeedMouseFocus;
	}

	void WidgetInput::setInheritsPick(bool _value)
	{
		mInheritsPick = _value;
	}

	bool WidgetInput::getInheritsPick() const
	{
		return mInheritsPick;
	}

	bool WidgetInput::getRootMouseFocus() const
	{
		return mRootMouseFocus;
	}

	bool WidgetInput::getRootKeyFocus() const
	{
		return mRootKeyFocus;
	}

	void WidgetInput::_setRootMouseFocus(bool _value)
	{
		mRootMouseFocus = _value;
	}

	void WidgetInput::_setRootKeyFocus(bool _value)
	{
		mRootKeyFocus = _value;
	}

	void WidgetInput::onMouseLostFocus(Widget* _new)
	{
	}

	void WidgetInput::onMouseSetFocus(Widget* _old)
	{
	}

	void WidgetInput::onMouseDrag(int _left, int _top, MouseButton _id)
	{
	}

	void WidgetInput::onMouseMove(int _left, int _top)
	{
	}

	void WidgetInput::onMouseWheel(int _rel)
	{
	}

	void WidgetInput::onMouseButtonPressed(int _left, int _top, MouseButton _id)
	{
	}

	void WidgetInput::onMouseButtonReleased(int _left, int _top, MouseButton _id)
	{
	}

	void WidgetInput::onMouseButtonClick()
	{
	}

	void WidgetInput::onMouseButtonDoubleClick()
	{
	}

	void WidgetInput::onKeyLostFocus(Widget* _new)
	{
	}

	void WidgetInput::onKeySetFocus(Widget* _old)
	{
	}

	void WidgetInput::onKeyButtonPressed(KeyCode _key, Char _char)
	{
	}

	void WidgetInput::onKeyButtonReleased(KeyCode _key)
	{
	}

	void WidgetInput::onMouseChangeRootFocus(bool _focus)
	{
	}

	void WidgetInput::onKeyChangeRootFocus(bool _focus)
	{
	}

} // namespace MyGUI


text:
namespace Humidifier.SecurityHub
{
    using System.Collections.Generic;

    public class Hub : Humidifier.Resource
    {
        public override string AWSTypeName
        {
            get
            {
                return @"AWS::SecurityHub::Hub";
            }
        }

        /// <summary>
        /// Tags
        /// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-securityhub-hub.html#cfn-securityhub-hub-tags
        /// Required: False
        /// UpdateType: Mutable
        /// PrimitiveType: Json
        /// </summary>
        public dynamic Tags
        {
            get;
            set;
        }
    }
}


text:
import { async, ComponentFixture, TestBed } from '@angular/core/testing';
import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
import { TranslateModule } from '@ngx-translate/core';
import { RouterTestingModule } from '@angular/router/testing';

import { I18nService } from '../../providers/translation/i18n.service';
import { HeaderComponent } from './header.component';

describe('HeaderComponent', () => {
  let component: HeaderComponent;
  let fixture: ComponentFixture<HeaderComponent>;

  beforeEach(async(() => {
    TestBed.configureTestingModule({
      imports: [
        RouterTestingModule,
        NgbModule.forRoot(),
        TranslateModule.forRoot()
      ],
      declarations: [HeaderComponent],
      providers: [
        I18nService
      ]
    })
    .compileComponents();
  }));

  beforeEach(() => {
    fixture = TestBed.createComponent(HeaderComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });
});


text:
FROM ortools/cmake:system_deps_swig AS env
RUN pacman -Syu --noconfirm dotnet-sdk
# Trigger first run experience by running arbitrary cmd
RUN dotnet --info

FROM env AS devel
WORKDIR /home/project
COPY . .

FROM devel AS build
RUN cmake -S. -Bbuild -DBUILD_DEPS=OFF \
 -DUSE_COINOR=ON -DUSE_GLPK=ON -DUSE_SCIP=OFF \
 -DBUILD_DOTNET=ON -DUSE_DOTNET_CORE_31=OFF -DBUILD_CXX_SAMPLES=OFF -DBUILD_CXX_EXAMPLES=OFF
RUN cmake --build build --target all -v
RUN cmake --build build --target install

FROM build AS test
RUN CTEST_OUTPUT_ON_FAILURE=1 cmake --build build --target test

FROM env AS install_env
WORKDIR /home/sample
COPY --from=build /home/project/build/dotnet/packages/*.nupkg ./

FROM install_env AS install_devel
COPY cmake/samples/dotnet .

FROM install_devel AS install_build
RUN dotnet build

FROM install_build AS install_test
RUN dotnet test


text:
<!DOCTYPE html>

        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">

        <title>My Dashboard</title>

        <meta name="description" content="">
        <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0">

        <link rel="stylesheet" href="main.css">

                      My Dashboard

Home

Settings

            {{{ reactOutput }}}


text:
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <ProgressBar
        android:id="@+id/progressBar"
        style="@android:style/Widget.ProgressBar.Horizontal"
        android:layout_width="0dp"
        android:layout_height="10dp"
        android:layout_marginBottom="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:max="100"
        android:progress="0"
        android:progressDrawable="@drawable/progress_bar"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <TextView
        android:id="@+id/progressTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/progressBar"
        android:layout_centerHorizontal="true"
        android:layout_marginEnd="8dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:textSize="42sp"
        app:layout_constraintEnd_toEndOf="@+id/progressBar"
        app:layout_constraintStart_toStartOf="@+id/progressBar"
        app:layout_constraintTop_toBottomOf="@+id/progressBar"
        tools:text="65%" />

</android.support.constraint.ConstraintLayout>


text:
(function ($, w, undefined) {
  if (w.footable === undefined || w.foobox === null)
    throw new Error('Please check and make sure footable.js is included in the page and is loaded prior to this script.');

  var defaults = {
    striping: {
      enabled: true
    },
    classes: {
      striping: {
        odd: 'footable-odd',
        even: 'footable-even'
      }
    }
  };

  function Striping() {
    var p = this;
    p.name = 'Footable Striping';
    p.init = function (ft) {
      p.footable = ft;
      $(ft.table)
        .unbind('striping')
        .bind({
          'footable_initialized.striping footable_row_removed.striping footable_redrawn.striping footable_sorted.striping footable_filtered.striping': function () {

            if ($(this).data('striping') === false) return;

            p.setupStriping(ft);
          }
        });
    };

    p.setupStriping = function (ft) {

      var rowIndex = 0;
      $(ft.table).find('> tbody > tr:not(.footable-row-detail)').each(function () {

        var $row = $(this);

        //Clean off old classes
        $row.removeClass(ft.options.classes.striping.even).removeClass(ft.options.classes.striping.odd);

        if (rowIndex % 2 === 0) {
          $row.addClass(ft.options.classes.striping.even);
        } else {
          $row.addClass(ft.options.classes.striping.odd);
        }

        rowIndex++;
      });
    };
  }

  w.footable.plugins.register(Striping, defaults);

})(jQuery, window);


text:
/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2017 Couchbase, Inc.
 *
 *   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.
 */
#include "client_cert_config.h"

#include <folly/portability/GTest.h>
#include <memcached/openssl.h>

#include <nlohmann/json.hpp>
#include <openssl/conf.h>
#include <openssl/engine.h>
#include <platform/dirutils.h>
#include <gsl/gsl>

using namespace cb::x509;

TEST(X509, ValidateStateDisabled) {
    // When the state is disabled we don't need any more parameters set
    auto config = ClientCertConfig::create(R"({"state": "disable"})"_json);
    EXPECT_TRUE(config);
    EXPECT_EQ(Mode::Disabled, config->getMode());
}

TEST(X509, ValidateStateEnable) {
    auto config = ClientCertConfig::create(R"({"state": "enable", "path":
                                            "subject.cn"})"_json);
    EXPECT_TRUE(config);
    EXPECT_EQ(Mode::Enabled, config->getMode());
}

TEST(X509, ValidateStateMandatory) {
    auto config = ClientCertConfig::create(R"({"state": "mandatory", "path":
"subject.cn"})"_json);
    EXPECT_TRUE(config);
    EXPECT_EQ(Mode::Mandatory, config->getMode());
}

TEST(X509, ValidateInvalidStateValue) {
    EXPECT_THROW(ClientCertConfig::create(R"({"state": 5})"_json),
                 nlohmann::json::exception);
}

TEST(X509, ValidateMissingState) {
    EXPECT_THROW(ClientCertConfig::create(R"({})"_json),
                 nlohmann::json::exception);
}

TEST(X509, ParseValidSingleEntryFormat) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "path": "san.dnsname",
    "prefix": "www.",
     "delimiter": ".,;"
})"_json);
    EXPECT_TRUE(config);
    EXPECT_EQ(1, config->getNumMappings());
    const auto& entry = config->getMapping(0);
    EXPECT_EQ("san.dnsname", entry.path);
    EXPECT_EQ("www.", entry.prefix);
    EXPECT_EQ(".,;", entry.delimiter);
}

TEST(X509, ParseValidMultipleEntryFormat) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "san.dnsname",
            "prefix": "www.",
            "delimiter": ".,;"
        },
        {
            "path": "subject.cn",
            "prefix": "",
            "delimiter": ""
        }
    ]
})"_json);
    EXPECT_TRUE(config);
    EXPECT_EQ(2, config->getNumMappings());

    // Make sure that the order is preserved
    {
        const auto& entry = config->getMapping(0);

        EXPECT_EQ("san.dnsname", entry.path);
        EXPECT_EQ("www.", entry.prefix);
        EXPECT_EQ(".,;", entry.delimiter);
    }

    {
        const auto& entry = config->getMapping(1);
        EXPECT_EQ("subject.cn", entry.path);
        EXPECT_TRUE(entry.prefix.empty());
        EXPECT_TRUE(entry.delimiter.empty());
    }
}

class SslParseCertTest : public ::testing::Test {
public:
    static void SetUpTestCase() {
        OPENSSL_init_ssl(0, nullptr);
        SSL_load_error_strings();
        ERR_load_BIO_strings();
        OpenSSL_add_all_algorithms();

        std::string certPath{SOURCE_ROOT};
        certPath.append("/tests/cert/parse-test.pem");
        certPath = cb::io::sanitizePath(certPath);
        auto data = cb::io::loadFile(certPath);
        auto* certbio = BIO_new_mem_buf(
                const_cast<void*>(static_cast<const void*>(data.data())),
                gsl::narrow<int>(data.size()));
        cert.reset(PEM_read_bio_X509(certbio, nullptr, nullptr, nullptr));
        BIO_free(certbio);
        ASSERT_TRUE(cert.get()) << "Error in reading certificate file: "
                                << certPath;
    }

    static void TearDownTestCase() {
        // Release the certificate
        cert.reset();

        // Global OpenSSL cleanup:
        ENGINE_cleanup();
        CONF_modules_unload(1);
        ERR_free_strings();
        EVP_cleanup();
        CRYPTO_cleanup_all_ex_data();
    }

    static cb::openssl::unique_x509_ptr cert;
};

cb::openssl::unique_x509_ptr SslParseCertTest::cert;

/*
 * The certificate used in these tests contains the following entry
 * for the common name:
 *
 *     CN=testappname
 */

TEST_F(SslParseCertTest, TestCN_EntireField) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "subject.cn",
            "prefix": "",
            "delimiter": ""
        }
    ]
})"_json);
    EXPECT_TRUE(config);
    auto statusPair = config->lookupUser(cert.get());
    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "testappname");
}

TEST_F(SslParseCertTest, TestCN_WithPrefix) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "subject.cn",
            "prefix": "test",
            "delimiter": ""
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());
    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "appname");
}

TEST_F(SslParseCertTest, TestCN_WithPrefixAndDelimiter) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "subject.cn",
            "prefix": "test",
            "delimiter": "n"
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());
    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "app");
}

TEST_F(SslParseCertTest, TestCN_PrefixAndMultipleDelimiters) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "subject.cn",
            "prefix": "test",
            "delimiter": "np"
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());
    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "a");
}

TEST_F(SslParseCertTest, TestCN_PrefixAndUnknownDelimiters) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "subject.cn",
            "prefix": "test",
            "delimiter": "x"
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());
    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "appname");
}

TEST_F(SslParseCertTest, TestCN_PrefixMissing) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "subject.cn",
            "prefix": "rand",
            "delimiter": "n"
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());
    ASSERT_EQ(statusPair.first, cb::x509::Status::NoMatch);
}

/*
 * The certificate used in these tests contains the following entry
 * for the SAN:
 *
 *       URI:urn:li:testurl_1
 *       URI:email:testapp@example.com
 *       URI:couchbase://myuser@mycluster/mybucket
 *       DNS:MyServerName
 */

TEST_F(SslParseCertTest, TestSAN_URI_EntireField) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "san.uri",
            "prefix": "",
            "delimiter": ""
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());
    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    // We should match the first entry
    ASSERT_EQ(statusPair.second, "urn:li:testurl_1");
}

TEST_F(SslParseCertTest, TestSAN_URI_UrnWithoutDelimiter) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "san.uri",
            "prefix": "urn:",
            "delimiter": "_"
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());
    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "li:testurl");
}

TEST_F(SslParseCertTest, TestSAN_URI_UrnWithDelimiter) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "san.uri",
            "prefix": "urn:",
            "delimiter": ":"
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());

    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "li");
}

TEST_F(SslParseCertTest, TestSAN_URI_MissingPrefix) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "san.uri",
            "prefix": "uri",
            "delimiter": ":-_"
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());
    ASSERT_EQ(statusPair.first, cb::x509::Status::NoMatch);
}

TEST_F(SslParseCertTest, TestSAN_URI_Email) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "san.uri",
            "prefix": "email:",
            "delimiter": "@"
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());

    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "testapp");
}

TEST_F(SslParseCertTest, TestSAN_DNS_EntireField) {
    auto config = ClientCertConfig::create(R"({
    "state": "enable",
    "prefixes": [
        {
            "path": "san.dnsname",
            "prefix": "",
            "delimiter": ""
        }
    ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());

    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "MyServerName");
}

TEST_F(SslParseCertTest, TestMatchForMultipleRules) {
    auto config = ClientCertConfig::create(R"({
  "state": "enable",
  "prefixes": [
    {
      "path": "subject.cn",
      "prefix": "NoMatch1",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch2",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch3",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch4",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch5",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch6",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch7",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch8",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch9",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch10",
      "delimiter": ""
    },
    {
      "path": "subject.cn",
      "prefix": "NoMatch11",
      "delimiter": ""
    },
    {
      "path": "san.dnsname",
      "prefix": "",
      "delimiter": ""
    }
  ]
})"_json);
    EXPECT_TRUE(config);

    auto statusPair = config->lookupUser(cert.get());

    ASSERT_EQ(statusPair.first, cb::x509::Status::Success);
    ASSERT_EQ(statusPair.second, "MyServerName");
}


text:
<!doctype html>

  <link rel="shortcut icon" href="static/images/favicon.ico" type="image/x-icon">
  <title>Builder (Closure Library API Documentation - JavaScript)</title>
  <link rel="stylesheet" href="static/css/base.css">
  <link rel="stylesheet" href="static/css/doc.css">
  <link rel="stylesheet" href="static/css/sidetree.css">
  <link rel="stylesheet" href="static/css/prettify.css">

  <meta charset="utf8">

      Closure Library API Documentation

        Go to class or file:
        <input type="text" id="ac">

        ui.editor.AbstractDialog.Builder
        Extends

            Object

    A builder class for the dialog control. All methods except build return this.

Useful links

Source Code

Inheritance

Object
     goog.ui.editor.AbstractDialog.Builder

Constructor

    goog.ui.editor.AbstractDialog.Builder(editorDialog)

Parameters

        editorDialog
        :
goog.ui.editor.AbstractDialog

Editor dialog object that will wrap the wrapped dialog object this builder will create.

Instance Methods

        Public
        Protected
        Private

         Defined in

              goog.ui.editor.AbstractDialog.Builder

        addButton(label, handler, opt_buttonId)

        ⇒
goog.ui.editor.AbstractDialog.Builder

       Adds a custom button to the dialog.

    <! -- Method details -->

        Arguments:

        label
        :
string

The caption for the button.

        handler
        :
function(goog.ui.Dialog.EventType):*

Function called when the button is clicked. It is recommended that this function be a method in the concrete subclass of AbstractDialog using this Builder, and that it dispatch an event (see handleOk).

        opt_buttonId
        :
string

Identifier to be used to access the button when calling AbstractDialog.getButtonElement().

        Returns:
goog.ui.editor.AbstractDialog.Builder

            This.

     code »

        addCancelButton(opt_label)

        ⇒
goog.ui.editor.AbstractDialog.Builder

       Adds a Cancel button to the dialog. Clicking this button will cause {@link
handleCancel} to run, subsequently dispatching a CANCEL event.

    <! -- Method details -->

        Arguments:

        opt_label
        :
string

The caption for the button, if not "Cancel".

        Returns:
goog.ui.editor.AbstractDialog.Builder

            This.

     code »

        addClassName(className)

        ⇒
goog.ui.editor.AbstractDialog.Builder

       Puts a CSS class on the dialog's main element.

    <! -- Method details -->

        Arguments:

        className
        :
string

The class to add.

        Returns:
goog.ui.editor.AbstractDialog.Builder

            This.

     code »

        addOkButton(opt_label)

        ⇒
goog.ui.editor.AbstractDialog.Builder

       Adds an OK button to the dialog. Clicking this button will cause {@link
handleOk} to run, subsequently dispatching an OK event.

    <! -- Method details -->

        Arguments:

        opt_label
        :
string

The caption for the button, if not "OK".

        Returns:
goog.ui.editor.AbstractDialog.Builder

            This.

     code »

        build()

        ⇒
goog.ui.Dialog

       Builds the wrapped dialog control. May only be called once, after which
no more methods may be called on this builder.

    <! -- Method details -->

        Returns:
goog.ui.Dialog

            The wrapped dialog control.

     code »

        setContent(contentElem)

        ⇒
goog.ui.editor.AbstractDialog.Builder

       Sets the content element of the dialog.

    <! -- Method details -->

        Arguments:

        contentElem
        :
Element

An element for the main body.

        Returns:
goog.ui.editor.AbstractDialog.Builder

            This.

     code »

        setTitle(title)

        ⇒
goog.ui.editor.AbstractDialog.Builder

       Sets the title of the dialog.

    <! -- Method details -->

        Arguments:

        title
        :
string

Title HTML (escaped).

        Returns:
goog.ui.editor.AbstractDialog.Builder

            This.

     code »

Package ui

Package Reference


text:
require 'spec_helper'

describe 'Awspec::Generator::Doc::Type' do
  it 'generate_doc output should be the same as doc/resource_types.md' do
    generated = Awspec::Generator::Doc::Type.generate_doc
    doc = File.read(File.dirname(__FILE__) + '/../../../doc/resource_types.md').sub(/\n*\z/, '')
    expect(generated).to eq doc
  end
end

types = Awspec::Helper::Type::TYPES
types.delete('base')
types.each do |type|
  describe 'Resource Type ' + type do
    let(:generator) { eval "Awspec::Generator::Doc::Type::#{type.camelize}.new" }
    it 'should generate doc' do
      generated = generator.generate_doc
      expect(generated).to include(type)
    end
  end
end


text:
package org.buildmlearn.toolkit.templates;

import android.app.Activity;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.support.v7.app.AlertDialog;
import android.view.View;
import android.widget.BaseAdapter;
import android.widget.EditText;
import android.widget.TextView;

import org.buildmlearn.toolkit.R;
import org.buildmlearn.toolkit.activity.TemplateEditorInterface;
import org.buildmlearn.toolkit.dictationtemplate.fragment.SplashFragment;
import org.buildmlearn.toolkit.model.Template;
import org.buildmlearn.toolkit.model.TemplateInterface;
import org.buildmlearn.toolkit.utilities.FileDialog;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

/**
 * @brief Dictation template code implementing methods of TemplateInterface
 * <p/>
 * Created by Anupam (opticod) on 4/7/16.
 */
public class DictationTemplate implements TemplateInterface {

    transient private DictationAdapter adapter;
    private ArrayList<DictationModel> dictData;
    private int templateId;

    public DictationTemplate() {
        dictData = new ArrayList<>();
    }

    private boolean validated(Context context, EditText title, EditText passage) {
        if (title == null || passage == null) {
            return false;
        }

        String titleText = title.getText().toString().trim();
        String passageText = passage.getText().toString().trim();

        if ("".equals(titleText)) {
            title.setError(context.getString(R.string.dictation_template_title_hint));
            return false;
        } else if ("".equals(passageText)) {
            passage.setError(context.getString(R.string.dictation_template_passage_hint));
            return false;
        }
        return true;
    }

    @Override
    public Object newTemplateEditorAdapter(Context context, final TemplateEditorInterface templateEditorInterface) {
        adapter = new DictationAdapter(context, dictData) {
            @Override
            public boolean onLongItemClick(int position, View view) {
                return templateEditorInterface.onItemLongClick(position, view);
            }

            @Override
            protected String getAuthorName() {
                return templateEditorInterface.getAuthorName();
            }

            @Override
            protected void setAuthorName(String authorName) {
                templateEditorInterface.setAuthorName(authorName);
            }

            @Override
            protected void setTitle(String title) {
                templateEditorInterface.setProjectTitle(title);
            }

            @Override
            protected void restoreToolbarColorSchema() {
                templateEditorInterface.restoreColorSchema();
            }

            @Override
            protected String getTitle() {
                return templateEditorInterface.getProjectTitle();
            }
        };
        setEmptyView((Activity) context);
        return adapter;
    }

    @Override
    public BaseAdapter newMetaEditorAdapter(Context context) {
        return null;
    }

    @Override
    public Object currentTemplateEditorAdapter() {
        return adapter;
    }

    @Override
    public BaseAdapter currentMetaEditorAdapter() {
        return null;
    }

    @Override
    public BaseAdapter loadProjectMetaEditor(Context context, Document doc) {
        return null;
    }

    @Override
    public Object loadProjectTemplateEditor(Context context, ArrayList<Element> data, final TemplateEditorInterface templateEditorInterface) {
        dictData = new ArrayList<>();
        for (Element item : data) {
            String dictTitle = item.getElementsByTagName(DictationModel.TITLE_TAG).item(0).getTextContent();
            String dictPassage = item.getElementsByTagName(DictationModel.PASSAGE_TAG).item(0).getTextContent();
            dictData.add(new DictationModel(dictTitle, dictPassage));
        }
        adapter = new DictationAdapter(context, dictData) {
            @Override
            public boolean onLongItemClick(int position, View view) {
                return templateEditorInterface.onItemLongClick(position, view);
            }

            @Override
            protected String getAuthorName() {
                return templateEditorInterface.getAuthorName();
            }

            @Override
            protected void setAuthorName(String authorName) {
                templateEditorInterface.setAuthorName(authorName);
            }

            @Override
            protected void setTitle(String title) {
                templateEditorInterface.setProjectTitle(title);
            }

            @Override
            protected void restoreToolbarColorSchema() {
                templateEditorInterface.restoreColorSchema();
            }

            @Override
            protected String getTitle() {
                return templateEditorInterface.getProjectTitle();
            }
        };
        setEmptyView((Activity) context);
        return adapter;
    }

    @Override
    public String getTitle() {
        return "Dictation Template";
    }

    @Override
    public void addItem(final Activity activity) {

        final View dialogView = View.inflate(activity,R.layout.dict_dialog_add_edit_data, null);
        final AlertDialog dialog = new AlertDialog.Builder(activity)
                .setTitle(R.string.info_add_new_title)
                .setView(dialogView,
                        activity.getResources().getDimensionPixelSize(R.dimen.spacing_left),
                        activity.getResources().getDimensionPixelSize(R.dimen.spacing_top),
                        activity.getResources().getDimensionPixelSize(R.dimen.spacing_right),
                        activity.getResources().getDimensionPixelSize(R.dimen.spacing_bottom))
                .setPositiveButton(R.string.info_template_add, null)
                .setNegativeButton(R.string.info_template_cancel, null)
                .create();
        dialog.show();

        final EditText title = (EditText) dialogView.findViewById(R.id.dict_title);
        final EditText passage = (EditText) dialogView.findViewById(R.id.dict_passage);

        dialogView.findViewById(R.id.upload).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                FileDialog fileDialog = new FileDialog(activity);
                fileDialog.setFileEndsWith();
                fileDialog.addFileListener(new FileDialog.FileSelectListener() {
                    public void fileSelected(File file) {
                        ((TextView) dialogView.findViewById(R.id.file_name)).setText(file.toString());
                        ((TextView) dialogView.findViewById(R.id.dict_passage)).setText(readFile(file));
                    }
                });
                fileDialog.showDialog();
            }
        });

        dialog.getButton(DialogInterface.BUTTON_POSITIVE).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                if (validated(activity, title, passage)) {
                    String titleText = title.getText().toString().trim();
                    String passageText = passage.getText().toString().trim();

                    DictationModel temp = new DictationModel(titleText, passageText);
                    dictData.add(temp);
                    adapter.notifyDataSetChanged();
                    setEmptyView(activity);

                    dialog.dismiss();
                }

            }
        });

    }

    @Override
    public void addMetaData(Activity activity) {

    }

    @Override
    public void editItem(final Activity activity, final int position) {

        final View dialogView = View.inflate(activity,R.layout.dict_dialog_add_edit_data, null);
        final AlertDialog dialog = new AlertDialog.Builder(activity)
                .setTitle(R.string.info_edit_title)
                .setView(dialogView,
                        activity.getResources().getDimensionPixelSize(R.dimen.spacing_left),
                        activity.getResources().getDimensionPixelSize(R.dimen.spacing_top),
                        activity.getResources().getDimensionPixelSize(R.dimen.spacing_right),
                        activity.getResources().getDimensionPixelSize(R.dimen.spacing_bottom))
                .setPositiveButton(R.string.info_template_ok, null)
                .setNegativeButton(R.string.info_template_cancel, null)
                .create();
        dialog.show();

        final DictationModel data = dictData.get(position);

        final EditText title = (EditText) dialogView.findViewById(R.id.dict_title);
        final EditText passage = (EditText) dialogView.findViewById(R.id.dict_passage);
        title.setText(data.getTitle().trim());
        passage.setText(data.getPassage().trim());

        dialogView.findViewById(R.id.upload).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                FileDialog fileDialog = new FileDialog(activity);
                fileDialog.setFileEndsWith();
                fileDialog.addFileListener(new FileDialog.FileSelectListener() {
                    public void fileSelected(File file) {
                        ((TextView) dialogView.findViewById(R.id.file_name)).setText(file.toString());
                        ((TextView) dialogView.findViewById(R.id.dict_passage)).setText(readFile(file));
                    }
                });
                fileDialog.showDialog();
            }
        });

        dialog.getButton(DialogInterface.BUTTON_POSITIVE).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                if (validated(activity, title, passage)) {

                    String titleText = title.getText().toString().trim();
                    String passageText = passage.getText().toString().trim();

                    data.setTitle(titleText);
                    data.setPassage(passageText);
                    adapter.notifyDataSetChanged();
                    dialog.dismiss();
                }
            }
        });
    }

    @Override
    public Object deleteItem(Activity activity, int position) {
        DictationModel dictationModel = dictData.get(position);
        dictData.remove(position);
        setEmptyView(activity);
        adapter.notifyDataSetChanged();
        setEmptyView(activity);
        return dictationModel;
    }

    @Override
    public void restoreItem(Activity activity, int position, Object object) {
        if (object instanceof DictationModel) {
            DictationModel dictationModel = (DictationModel) object;
            if (dictationModel != null) {
                dictData.add(position, dictationModel);
                adapter.notifyDataSetChanged();
                setEmptyView(activity);
            }
        }
    }

    @Override
    public ArrayList<Element> getItems(Document doc) {
        ArrayList<Element> itemElements = new ArrayList<>();

        for (DictationModel data : dictData) {

            itemElements.add(data.getXml(doc));
        }

        return itemElements;
    }

    @Override
    public android.support.v4.app.Fragment getSimulatorFragment(String filePathWithName) {
        return SplashFragment.newInstance(filePathWithName);
    }

    @Override
    public void setTemplateId(int templateId) {
        this.templateId = templateId;
    }

    @Override
    public String getAssetsFileName(Context context) {
        Template[] templates = Template.values();
        return context.getString(templates[templateId].getAssetsName());
    }

    @Override
    public String getAssetsFilePath() {
        return "assets/";
    }

    @Override
    public String getApkFilePath() {
        return "DictationApp.apk";
    }

    @Override
    public void onActivityResult(Context context, int requestCode, int resultCode, Intent intent) {
        // This is intentionally empty
    }

    @Override
    public boolean moveDown(Activity activity, int selectedPosition) {
        try {
            //Check already at last
            if (selectedPosition == dictData.size() - 1)
                return false;
            Collections.swap(dictData, selectedPosition, selectedPosition + 1);
            adapter.notifyDataSetChanged();
            return true;
        } catch (IndexOutOfBoundsException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean moveUp(Activity activity, int selectedPosition) {
        try {
            //Check already at top
            if (selectedPosition == 0)
                return false;
            Collections.swap(dictData, selectedPosition, selectedPosition - 1);
            adapter.notifyDataSetChanged();
            return true;
        } catch (IndexOutOfBoundsException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * @brief Toggles the visibility of empty text if Array has zero elements
     */
    private void setEmptyView(Activity activity) {
        if (dictData.size() < 1) {
            activity.findViewById(R.id.empty).setVisibility(View.VISIBLE);
        } else {
            activity.findViewById(R.id.empty).setVisibility(View.GONE);
        }
    }

    private String readFile(File file) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line).append("\n");
            }
            reader.close();
            return sb.toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }
}


text:
namespace physical_web {

// Test Values ----------------------------------------------------------------
const char kUrl[] = "https://www.google.com";

// TestPhysicalWebDataSource --------------------------------------------------

class TestPhysicalWebDataSource : public PhysicalWebDataSourceImpl {
 public:
  TestPhysicalWebDataSource() {}
  ~TestPhysicalWebDataSource() override {}

  void StartDiscovery(bool network_request_enabled) override;
  void StopDiscovery() override;
  std::unique_ptr<base::ListValue> GetMetadata() override;
  bool HasUnresolvedDiscoveries() override;
};
void TestPhysicalWebDataSource::StartDiscovery(bool network_request_enabled) {}

void TestPhysicalWebDataSource::StopDiscovery() {}

std::unique_ptr<base::ListValue> TestPhysicalWebDataSource::GetMetadata() {
  return NULL;
}

bool TestPhysicalWebDataSource::HasUnresolvedDiscoveries() {
  return false;
}

// TestPhysicalWebListener ----------------------------------------------------

class TestPhysicalWebListener : public PhysicalWebListener {
 public:
  TestPhysicalWebListener()
      : on_found_notified_(false),
        on_lost_notified_(false),
        on_distance_changed_notified_(false) {}

  ~TestPhysicalWebListener() {}

  void OnFound(const std::string& url) override {
    on_found_notified_ = true;
    last_event_url_ = url;
  }

  void OnLost(const std::string& url) override {
    on_lost_notified_ = true;
    last_event_url_ = url;
  }

  void OnDistanceChanged(const std::string& url,
                         double distance_estimate) override {
    on_distance_changed_notified_ = true;
    last_event_url_ = url;
  }

  bool OnFoundNotified() { return on_found_notified_; }

  bool OnLostNotified() { return on_lost_notified_; }

  bool OnDistanceChangedNotified() { return on_distance_changed_notified_; }

  std::string LastEventUrl() { return last_event_url_; }

 private:
  bool on_found_notified_;
  bool on_lost_notified_;
  bool on_distance_changed_notified_;
  std::string last_event_url_;
};

// PhysicalWebDataSourceImplTest ----------------------------------------------

class PhysicalWebDataSourceImplTest : public ::testing::Test {
 public:
  PhysicalWebDataSourceImplTest() {}
  ~PhysicalWebDataSourceImplTest() override {}

  // testing::Test
  void SetUp() override;
  void TearDown() override;

 protected:
  TestPhysicalWebDataSource data_source_;
  TestPhysicalWebListener listener_;
};

void PhysicalWebDataSourceImplTest::SetUp() {
  data_source_.RegisterListener(&listener_);
}

void PhysicalWebDataSourceImplTest::TearDown() {
  data_source_.UnregisterListener(&listener_);
}

// Tests ----------------------------------------------------------------------

TEST_F(PhysicalWebDataSourceImplTest, OnFound) {
  data_source_.NotifyOnFound(kUrl);
  EXPECT_TRUE(listener_.OnFoundNotified());
  EXPECT_FALSE(listener_.OnLostNotified());
  EXPECT_FALSE(listener_.OnDistanceChangedNotified());
  EXPECT_EQ(kUrl, listener_.LastEventUrl());
}

TEST_F(PhysicalWebDataSourceImplTest, OnLost) {
  data_source_.NotifyOnLost(kUrl);
  EXPECT_FALSE(listener_.OnFoundNotified());
  EXPECT_TRUE(listener_.OnLostNotified());
  EXPECT_FALSE(listener_.OnDistanceChangedNotified());
  EXPECT_EQ(kUrl, listener_.LastEventUrl());
}

TEST_F(PhysicalWebDataSourceImplTest, OnDistanceChanged) {
  data_source_.NotifyOnDistanceChanged(kUrl, 0.0);
  EXPECT_FALSE(listener_.OnFoundNotified());
  EXPECT_FALSE(listener_.OnLostNotified());
  EXPECT_TRUE(listener_.OnDistanceChangedNotified());
  EXPECT_EQ(kUrl, listener_.LastEventUrl());
}

TEST_F(PhysicalWebDataSourceImplTest, OnFoundNotRegistered) {
  data_source_.UnregisterListener(&listener_);
  data_source_.NotifyOnFound(kUrl);
  EXPECT_FALSE(listener_.OnFoundNotified());
  EXPECT_FALSE(listener_.OnLostNotified());
  EXPECT_FALSE(listener_.OnDistanceChangedNotified());
  EXPECT_TRUE(listener_.LastEventUrl().empty());
}

TEST_F(PhysicalWebDataSourceImplTest, OnLostNotRegistered) {
  data_source_.UnregisterListener(&listener_);
  data_source_.NotifyOnLost(kUrl);
  EXPECT_FALSE(listener_.OnFoundNotified());
  EXPECT_FALSE(listener_.OnLostNotified());
  EXPECT_FALSE(listener_.OnDistanceChangedNotified());
  EXPECT_TRUE(listener_.LastEventUrl().empty());
}

TEST_F(PhysicalWebDataSourceImplTest, OnDistanceChangedNotRegistered) {
  data_source_.UnregisterListener(&listener_);
  data_source_.NotifyOnDistanceChanged(kUrl, 0.0);
  EXPECT_FALSE(listener_.OnFoundNotified());
  EXPECT_FALSE(listener_.OnLostNotified());
  EXPECT_FALSE(listener_.OnDistanceChangedNotified());
  EXPECT_TRUE(listener_.LastEventUrl().empty());
}

}  // namespace physical_web


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.7"/>
<title>OpenWeatherMap: OWMAPIService Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

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

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

OpenWeatherMap

Main Page

Classes

Files

          <input type="text" id="MSearchField" value="Search" accesskey="S"
               onfocus="searchBox.OnSearchFieldFocus(true)"
               onblur="searchBox.OnSearchFieldFocus(false)"
               onkeyup="searchBox.OnSearchFieldChange(event)"/>

Class List

Class Index

Class Hierarchy

Class Members

 All Classes Functions Properties

Instance Methods |
Class Methods |
Properties |
List of all members

OWMAPIService Class Reference

Inheritance diagram for OWMAPIService:

  <map id="OWMAPIService_map" name="OWMAPIService_map">
</map>

Instance Methods

(void) 	- searchWeatherCityByName:withCompletion:

(void) 	- searchWeatherCityByGeographicCoordinats:withCompletion:

(void) 	- searchCityByName:withCompletion:

(void) 	- searchCitiesByCoordinatsLeftTop:rightBottom:andZoomMap:withCompletion:

(void) 	- searchForecastForCityByName:withCompletion:

(void) 	- searchForecastDailyForCityByName:forDays:withCompletion:

(NSString *) 	- htmlStringWithDailyWeatherByGeographicCoordinats:

(NSURL *) 	- urlWithWeather

(NSURL *) 	- urlWithWeatherAndStations

(NSURL *) 	- urlWithCloudsWeather

(NSURL *) 	- urlWithQuantityWeather

(NSURL *) 	- urlWithSeaLevelWeather

(NSURL *) 	- urlWithSnowWeather

(NSURL *) 	- urlWithTemperatureWeather

(NSURL *) 	- urlWithWindWeather

Class Methods

(id) 	+ sharedInstance

Properties

OWMLanguage * 	apiLanguage

NSString * 	hostApiPath

NSString * 	appId

NSString * 	unitType

Method Documentation

          - (NSString *) htmlStringWithDailyWeatherByGeographicCoordinats:

          (CLLocationCoordinate2D)
          coordinate

Function provides HTML string with weather for latitude and longitude parameters, html string can be used for display webpage for example with UIWebView

Parameters

coordinate	CLLLocationCoordinate2D for location coordinats

Returns

response is given with NSString object, can be used in UIWebView

          - (void) searchCitiesByCoordinatsLeftTop:

          (CLLocationCoordinate2D)
          leftTopCoordinate

          rightBottom:

          (CLLocationCoordinate2D)
          rightBottomCoordinate

          andZoomMap:

          (float)
          zoomLevel

          withCompletion:

          (CompletionBlockWithObject)
          completion

Request for searching city weathers with bbox

Parameters

leftTopCoordinate	CLLLocationCoordinate2D for left top corner

rightBottomCoordinate	CLLLocationCoordinate2D for right bottom corner

zoomLevel	zooming level

completion	response is given with CityWeather object

          - (void) searchCityByName:

          (NSString*)
          cityname

          withCompletion:

          (CompletionBlockWithObject)
          completion

Request for searching city with name

Parameters

cityname	full city name should be given

completion	response is given with City object

          - (void) searchForecastDailyForCityByName:

          (NSString*)
          cityname

          forDays:

          (NSInteger)
          days

          withCompletion:

          (CompletionBlockWithObject)
          completion

Request for searching daily forecast for particular city

Parameters

cityname	full city name should be given

days	define for how many days do you want to get forecast

completion	response is given with CityForecastDaily object

          - (void) searchForecastForCityByName:

          (NSString*)
          cityname

          withCompletion:

          (CompletionBlockWithObject)
          completion

Request for searching forecast for particular city with name

Parameters

cityname	full city name should be given

completion	response is given with CityForecast object

          - (void) searchWeatherCityByGeographicCoordinats:

          (CLLocationCoordinate2D)
          coordinate

          withCompletion:

          (CompletionBlockWithObject)
          completion

Request for weather in city with lat and lon parameters

Parameters

coordinate	geographic coordinats should be given for defined location

completion	response is given with CityWeather model

          - (void) searchWeatherCityByName:

          (NSString*)
          cityname

          withCompletion:

          (CompletionBlockWithObject)
          completion

Request for weather by city name

Parameters

cityname	full city name should be given

completion	response is given with CityWeather model

          - (NSURL *) urlWithCloudsWeather

Functions provides NSURL for appropriate layer with cloud weather, can be used in UIWebView

Returns

response is given with NSURL

          - (NSURL *) urlWithQuantityWeather

Functions provides NSURL for appropriate layer with quantity weather, can be used in UIWebView

Returns

response is given with NSURL

          - (NSURL *) urlWithSeaLevelWeather

Functions provides NSURL for appropriate layer with sea level weather, can be used in UIWebView

Returns

response is given with NSURL

          - (NSURL *) urlWithSnowWeather

Functions provides NSURL for appropriate layer with snow weather, can be used in UIWebView

Returns

response is given with NSURL

          - (NSURL *) urlWithTemperatureWeather

Functions provides NSURL for appropriate layer with temperature weather, can be used in UIWebView

Returns

response is given with NSURL

          - (NSURL *) urlWithWeather

Functions provides NSURL for appropriate layer with weather, can be used in UIWebView

Returns

response is given with NSURL

          - (NSURL *) urlWithWeatherAndStations

Functions provides NSURL for appropriate layer with weather and station, can be used in UIWebView

Returns

response is given with NSURL

          - (NSURL *) urlWithWindWeather

Functions provides NSURL for appropriate layer with wind weather, can be used in UIWebView

Returns

response is given with NSURL

Property Documentation

          - (OWMLanguage*) apiLanguage

readwritenonatomicretain

Property for set the language

          - (NSString*) appId

readwritenonatomicretain

Property for set API Key provided by openweathermap.org

          - (NSString*) hostApiPath

readwritenonatomicretain

Property for set API host

          - (NSString*) unitType

readwritenonatomicretain

Property for set unit type, metric or imperial

The documentation for this class was generated from the following files:

APIService/OWMAPIService.h

APIService/OWMAPIService.m

<address class="footer">
Generated on Sat Mar 7 2015 15:59:37 for OpenWeatherMap by

 1.8.7
</address>