text:
using System;
using System.Linq;
using System.Collections.Generic;
using System.Configuration;
using System.Net;
using System.Security;

namespace Bugsnag.ConfigurationSection
{
  public class Configuration : System.Configuration.ConfigurationSection, IConfiguration
  {
    private static Configuration _configuration = ConfigurationManager.GetSection("bugsnag") as Configuration ?? new Configuration();

    public static Configuration Settings
    {
      get { return _configuration; }
    }

    private const string apiKey = "apiKey";

    [ConfigurationProperty(apiKey, IsRequired = true)]
    public string ApiKey
    {
      get
      {
        switch (ElementInformation.Properties[apiKey].ValueOrigin)
        {
          case PropertyValueOrigin.Inherited:
          case PropertyValueOrigin.SetHere:
            return this[apiKey] as string;
          default:
            return null;
        }
      }
    }

    private const string appType = "appType";

    [ConfigurationProperty(appType, IsRequired = false)]
    public string AppType
    {
      get
      {
        switch (ElementInformation.Properties[appType].ValueOrigin)
        {
          case PropertyValueOrigin.Inherited:
          case PropertyValueOrigin.SetHere:
            return this[appType] as string;
          default:
            return null;
        }
      }
    }

    private const string appVersion = "appVersion";

    [ConfigurationProperty(appVersion, IsRequired = false)]
    public string AppVersion
    {
      get
      {
        switch (ElementInformation.Properties[appVersion].ValueOrigin)
        {
          case PropertyValueOrigin.Inherited:
          case PropertyValueOrigin.SetHere:
            return this[appVersion] as string;
          default:
            return null;
        }
      }
    }

    private const string endpoint = "endpoint";

    [ConfigurationProperty(endpoint, IsRequired = false, DefaultValue = Bugsnag.Configuration.DefaultEndpoint)]
    private string InternalEndpoint
    {
      get { return this[endpoint] as string; }
    }

    public Uri Endpoint
    {
      get { return new Uri(InternalEndpoint); }
    }

    private const string autoNotify = "autoNotify";

    [ConfigurationProperty(autoNotify, IsRequired = false, DefaultValue = true)]
    public bool AutoNotify
    {
      get
      {
        return (bool)this[autoNotify];
      }
    }

    private const string notifyReleaseStages = "notifyReleaseStages";

    [ConfigurationProperty(notifyReleaseStages, IsRequired = false)]
    private string InternalNotifyReleaseStages
    {
      get
      {
        switch (ElementInformation.Properties[notifyReleaseStages].ValueOrigin)
        {
          case PropertyValueOrigin.Inherited:
          case PropertyValueOrigin.SetHere:
            return this[notifyReleaseStages] as string;
          default:
            return null;
        }
      }
    }

    public string[] NotifyReleaseStages
    {
      get
      {
        if (InternalNotifyReleaseStages != null)
        {
          return InternalNotifyReleaseStages.Split(',');
        }

        return null;
      }
    }

    private const string releaseStage = "releaseStage";

    [ConfigurationProperty(releaseStage, IsRequired = false)]
    public string ReleaseStage
    {
      get
      {
        switch (ElementInformation.Properties[releaseStage].ValueOrigin)
        {
          case PropertyValueOrigin.Inherited:
          case PropertyValueOrigin.SetHere:
            return this[releaseStage] as string;
          default:
            return null;
        }
      }
    }

    private const string projectRoots = "projectRoots";

    [ConfigurationProperty(projectRoots, IsRequired = false)]
    private string InternalProjectRoots
    {
      get
      {
        switch (ElementInformation.Properties[projectRoots].ValueOrigin)
        {
          case PropertyValueOrigin.Inherited:
          case PropertyValueOrigin.SetHere:
            return this[projectRoots] as string;
          default:
            return null;
        }
      }
    }

    public string[] ProjectRoots
    {
      get
      {
        if (InternalProjectRoots != null)
        {
          return InternalProjectRoots.Split(',');
        }

        return null;
      }
    }

    private const string projectNamespaces = "projectNamespaces";

    [ConfigurationProperty(projectNamespaces, IsRequired = false)]
    private string InternalProjectNamespaces
    {
      get
      {
        switch (ElementInformation.Properties[projectNamespaces].ValueOrigin)
        {
          case PropertyValueOrigin.Inherited:
          case PropertyValueOrigin.SetHere:
            return this[projectNamespaces] as string;
          default:
            return null;
        }
      }
    }

    public string[] ProjectNamespaces
    {
      get
      {
        if (InternalProjectNamespaces != null)
        {
          return InternalProjectNamespaces.Split(',');
        }

        return null;
      }
    }

    private const string ignoreClasses = "ignoreClasses";

    [ConfigurationProperty(ignoreClasses, IsRequired = false)]
    private string InternalIgnoreClasses
    {
      get
      {
        switch (ElementInformation.Properties[ignoreClasses].ValueOrigin)
        {
          case PropertyValueOrigin.Inherited:
          case PropertyValueOrigin.SetHere:
            return this[ignoreClasses] as string;
          default:
            return null;
        }
      }
    }

    private Type[] _ignoreClasses;

    public Type[] IgnoreClasses
    {
      get
      {
        if (_ignoreClasses == null)
        {
          _ignoreClasses = CompleteIgnoreClasses
            .Select(t => Type.GetType(t))
            .Where(c => c != null)
            .ToArray();
        }

        return _ignoreClasses;
      }
    }

    private IEnumerable<string> CompleteIgnoreClasses
    {
      get
      {
        if (InternalIgnoreClasses != null)
        {
          foreach (var item in InternalIgnoreClasses.Split(','))
          {
            yield return item;
          }
        }

        if (InternalExtendedIgnoreClasses.Count > 0)
        {
          foreach (ExtendedIgnoreClass item in InternalExtendedIgnoreClasses)
          {
            yield return item.Name;
          }
        }
      }
    }

    private const string extendedIgnoreClasses = "assemblyQualifiedIgnoreClasses";

    [ConfigurationProperty(extendedIgnoreClasses, IsRequired = false)]
    private ExtendedIgnoreClassCollection InternalExtendedIgnoreClasses
    {
      get
      {
        return (ExtendedIgnoreClassCollection)this[extendedIgnoreClasses];
      }
    }

    [ConfigurationCollection(typeof(ExtendedIgnoreClass), AddItemName = "class", CollectionType = ConfigurationElementCollectionType.BasicMap)]
    class ExtendedIgnoreClassCollection : ConfigurationElementCollection
    {
      protected override ConfigurationElement CreateNewElement()
      {
        return new ExtendedIgnoreClass();
      }

      protected override object GetElementKey(ConfigurationElement element)
      {
        return ((ExtendedIgnoreClass)element).Name;
      }
    }

    class ExtendedIgnoreClass : ConfigurationElement
    {
      [ConfigurationProperty("name", IsRequired = true)]
      public string Name => (string)this["name"];
    }

    private const string metadataFilters = "metadataFilters";

    [ConfigurationProperty(metadataFilters, IsRequired = false)]
    private string InternalMetadataFilters
    {
      get
      {
        switch (ElementInformation.Properties[metadataFilters].ValueOrigin)
        {
          case PropertyValueOrigin.Inherited:
          case PropertyValueOrigin.SetHere:
            return this[metadataFilters] as string;
          default:
            return null;
        }
      }
    }

    public string[] MetadataFilters
    {
      get
      {
        if (InternalMetadataFilters != null)
        {
          return InternalMetadataFilters.Split(',');
        }

        return null;
      }
    }

    private const string metadata = "metadata";

    [ConfigurationProperty(metadata, IsRequired = false)]
    private GlobalMetadataCollection InternalGlobalMetadata
    {
      get { return (GlobalMetadataCollection)this[metadata]; }
    }

    public KeyValuePair<string, object>[] GlobalMetadata
    {
      get
      {
        if (InternalGlobalMetadata.Count > 0)
        {
          return InternalGlobalMetadata.Cast<GlobalMetadataItem>().Select(i => new KeyValuePair<string, object>(i.Key, i.Value)).ToArray();
        }

        return null;
      }
    }

    class GlobalMetadataItem : ConfigurationElement
    {
      [ConfigurationProperty("key", IsRequired = true)]
      public string Key { get { return (string)this["key"]; } }

      [ConfigurationProperty("value", IsRequired = true)]
      public string Value { get { return (string)this["value"]; } }
    }

    [ConfigurationCollection(typeof(GlobalMetadataItem), AddItemName = "item", CollectionType = ConfigurationElementCollectionType.BasicMap)]
    class GlobalMetadataCollection : ConfigurationElementCollection
    {
      protected override ConfigurationElement CreateNewElement()
      {
        return new GlobalMetadataItem();
      }

      protected override object GetElementKey(ConfigurationElement element)
      {
        return ((GlobalMetadataItem)element).Key;
      }
    }

    private const string autoCaptureSessions = "autoCaptureSessions";

    [ConfigurationProperty(autoCaptureSessions, IsRequired = false, DefaultValue = false)]
    public bool AutoCaptureSessions
    {
      get
      {
        return (bool)this[autoCaptureSessions];
      }
    }

    private const string sessionsEndpoint = "sessionsEndpoint";

    [ConfigurationProperty(sessionsEndpoint, IsRequired = false, DefaultValue = Bugsnag.Configuration.DefaultSessionEndpoint)]
    private string InternalSessionEndpoint
    {
      get { return this[sessionsEndpoint] as string; }
    }

    public Uri SessionEndpoint
    {
      get { return new Uri(InternalSessionEndpoint); }
    }

    public TimeSpan SessionTrackingInterval
    {
      get { return TimeSpan.FromSeconds(60); }
    }

    private const string proxyAddress = "proxyAddress";

    [ConfigurationProperty(proxyAddress, IsRequired = false)]
    private string ProxyAddress
    {
      get { return this[proxyAddress] as string; }
    }

    private const string proxyUsername = "proxyUsername";

    [ConfigurationProperty(proxyUsername, IsRequired = false)]
    private string ProxyUsername
    {
      get { return this[proxyUsername] as string; }
    }

    private const string proxyPassword = "proxyPassword";

    [ConfigurationProperty(proxyPassword, IsRequired = false)]
    private string ProxyPassword
    {
      get { return this[proxyPassword] as string; }
    }

    public IWebProxy Proxy
    {
      get
      {
        try
        {
          if (Polyfills.String.IsNullOrWhiteSpace(ProxyAddress)) return null;

          // we should probably store this so we don't try to create a new one each time this is accessed
          if (!string.IsNullOrEmpty(ProxyUsername) && !string.IsNullOrEmpty(ProxyPassword))
          {
            var credential = new NetworkCredential(ProxyUsername, ProxyPassword);
            return new WebProxy(ProxyAddress, false, null, credential);
          }
          return new WebProxy(ProxyAddress);
        }
        catch (UriFormatException)
        {
          return null;
        }
      }
    }

    private const string maximumBreadcrumbs = "maximumBreadcrumbs";

    [ConfigurationProperty(maximumBreadcrumbs, IsRequired = false, DefaultValue = 25)]
    public int MaximumBreadcrumbs
    {
      get { return (int)this[maximumBreadcrumbs]; }
    }
  }
}


text:
// TypeScript Version: 2.0

/// <reference types="@stdlib/types"/>

import { Collection } from '@stdlib/types/object';

/**
 * Interface describing `toWords`.
 */
interface ToWords {
	/**
	* Splits a double-precision floating-point number into a higher order word (unsigned 32-bit integer) and a lower order word (unsigned 32-bit integer).
	*
	* @param x - input value
	* @returns output array
	*
	* @example
	* var w = toWords( 3.14e201 );
	* // returns [ 1774486211, 2479577218 ]
	*/
	( x: number ): Array<number>;

	/**
	* Splits a double-precision floating-point number into a higher order word (unsigned 32-bit integer) and a lower order word (unsigned 32-bit integer) and assigns results to a provided output array.
	*
	* @param x - input value
	* @param out - output array
	* @param stride - output array stride
	* @param offset - output array index offset
	* @returns output array
	*
	* @example
	* var Uint32Array = require( `@stdlib/array/uint32` );
	*
	* var out = new Uint32Array( 2 );
	*
	* var w = toWords.assign( 3.14e201, out, 1, 0 );
	* // returns <Uint32Array>[ 1774486211, 2479577218 ]
	*
	* var bool = ( w === out );
	* // returns true
	*/
	assign( x: number, out: Collection, stride: number, offset: number ): Collection; // tslint-disable-line max-line-length
}

/**
* Splits a double-precision floating-point number into a higher order word (unsigned 32-bit integer) and a lower order word (unsigned 32-bit integer).
*
* @param x - input value
* @returns output array
*
* @example
* var w = toWords( 3.14e201 );
* // returns [ 1774486211, 2479577218 ]
*/
declare var toWords: ToWords;

// EXPORTS //

export = toWords;

redpajama_set_name: RedPajamaGithub


text:
package StudyGraphic;

import javax.swing.JPanel;

public class Panel01BA extends JPanel{

}


text:
<?php
/* vim: set expandtab sw=4 ts=4 sts=4: */
/**
 * Abstract class for the text file upload input transformations plugins
 *
 * @package    PhpMyAdmin-Transformations
 * @subpackage TextFileUpload
 */
namespace PhpMyAdmin\Plugins\Transformations\Abs;

use PhpMyAdmin\Plugins\IOTransformationsPlugin;

/**
 * Provides common methods for all of the text file upload
 * input transformations plugins.
 *
 * @package    PhpMyAdmin-Transformations
 * @subpackage TextFileUpload
 */
abstract class TextFileUploadTransformationsPlugin extends IOTransformationsPlugin
{
    /**
     * Gets the transformation description of the specific plugin
     *
     * @return string
     */
    public static function getInfo()
    {
        return __(
            'File upload functionality for TEXT columns. '
            . 'It does not have a textarea for input.'
        );
    }

    /**
     * Does the actual work of each specific transformations plugin.
     *
     * @param string $buffer  text to be transformed
     * @param array  $options transformation options
     * @param string $meta    meta information
     *
     * @return string
     */
    public function applyTransformation($buffer, array $options = array(), $meta = '')
    {
        return $buffer;
    }

    /**
     * Returns the html for input field to override default textarea.
     * Note: Return empty string if default textarea is required.
     *
     * @param array  $column               column details
     * @param int    $row_id               row number
     * @param string $column_name_appendix the name attribute
     * @param array  $options              transformation options
     * @param string $value                Current field value
     * @param string $text_dir             text direction
     * @param int    $tabindex             tab index
     * @param int    $tabindex_for_value   offset for the values tabindex
     * @param int    $idindex              id index
     *
     * @return string the html for input field
     */
    public function getInputHtml(
        array $column,
        $row_id,
        $column_name_appendix,
        array $options,
        $value,
        $text_dir,
        $tabindex,
        $tabindex_for_value,
        $idindex
    ) {
        $html = '';
        if (!empty($value)) {
            $html = '<input type="hidden" name="fields_prev' . $column_name_appendix
                . '" value="' . htmlspecialchars($value) . '"/>';
            $html .= '<input type="hidden" name="fields' . $column_name_appendix
                . '" value="' . htmlspecialchars($value) . '"/>';
        }
        $html .= '<input type="file" name="fields_upload'
            . $column_name_appendix . '"/>';

        return $html;
    }

    /* ~~~~~~~~~~~~~~~~~~~~ Getters and Setters ~~~~~~~~~~~~~~~~~~~~ */

    /**
     * Gets the transformation name of the specific plugin
     *
     * @return string
     */
    public static function getName()
    {
        return "Text file upload";
    }
}


text:
        Posted on

        by

    No articles yet, why don't you create one?


text:
.class public Lcom/facebook/widget/FriendPickerFragment;
.super Lcom/facebook/widget/PickerFragment;
.source ""

# annotations
.annotation system Ldalvik/annotation/MemberClasses;
    value = {
        Lcom/facebook/widget/FriendPickerFragment$ImmediateLoadingStrategy;
    }
.end annotation

.annotation system Ldalvik/annotation/Signature;
    value = {
        "Lcom/facebook/widget/PickerFragment<Lcom/facebook/model/GraphUser;>;"
    }
.end annotation

# static fields
.field private static final ID:Ljava/lang/String; = "id"

.field public static final MULTI_SELECT_BUNDLE_KEY:Ljava/lang/String; = "com.facebook.widget.FriendPickerFragment.MultiSelect"

.field private static final NAME:Ljava/lang/String; = "name"

.field public static final USER_ID_BUNDLE_KEY:Ljava/lang/String; = "com.facebook.widget.FriendPickerFragment.UserId"

# instance fields
.field private multiSelect:Z

.field private preSelectedFriendIds:Ljava/util/List;
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "Ljava/util/List<Ljava/lang/String;>;"
        }
    .end annotation
.end field

.field private userId:Ljava/lang/String;

# direct methods
.method public constructor <init>()V
    .locals 1

    .line 64
    const/4 v0, 0x0

    invoke-direct {p0, v0}, Lcom/facebook/widget/FriendPickerFragment;-><init>(Landroid/os/Bundle;)V

    .line 65
    return-void
.end method

.method public constructor <init>(Landroid/os/Bundle;)V
    .locals 2
    .annotation build Landroid/annotation/SuppressLint;
        value = {
            "ValidFragment"
        }
    .end annotation

    .line 74
    const-class v0, Lcom/facebook/model/GraphUser;

    sget v1, Lcom/facebook/android/R$layout;->com_facebook_friendpickerfragment:I

    invoke-direct {p0, v0, v1, p1}, Lcom/facebook/widget/PickerFragment;-><init>(Ljava/lang/Class;ILandroid/os/Bundle;)V

    .line 56
    const/4 v0, 0x1

    iput-boolean v0, p0, Lcom/facebook/widget/FriendPickerFragment;->multiSelect:Z

    .line 58
    new-instance v0, Ljava/util/ArrayList;

    invoke-direct {v0}, Ljava/util/ArrayList;-><init>()V

    iput-object v0, p0, Lcom/facebook/widget/FriendPickerFragment;->preSelectedFriendIds:Ljava/util/List;

    .line 75
    invoke-direct {p0, p1}, Lcom/facebook/widget/FriendPickerFragment;->setFriendPickerSettingsFromBundle(Landroid/os/Bundle;)V

    .line 76
    return-void
.end method

.method private createRequest(Ljava/lang/String;Ljava/util/Set;Lcom/facebook/Session;)Lcom/facebook/Request;
    .locals 3
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "(Ljava/lang/String;Ljava/util/Set<Ljava/lang/String;>;Lcom/facebook/Session;)Lcom/facebook/Request;"
        }
    .end annotation

    .line 253
    new-instance v0, Ljava/lang/StringBuilder;

    invoke-direct {v0}, Ljava/lang/StringBuilder;-><init>()V

    invoke-virtual {v0, p1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    move-result-object v0

    const-string v1, "/friends"

    invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    move-result-object v0

    invoke-virtual {v0}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;

    move-result-object v0

    const/4 v1, 0x0

    invoke-static {p3, v0, v1}, Lcom/facebook/Request;->newGraphPathRequest(Lcom/facebook/Session;Ljava/lang/String;Lcom/facebook/Request$Callback;)Lcom/facebook/Request;

    move-result-object p1

    .line 255
    new-instance v0, Ljava/util/HashSet;

    invoke-direct {v0, p2}, Ljava/util/HashSet;-><init>(Ljava/util/Collection;)V

    move-object p2, v0

    .line 256
    const/4 v0, 0x2

    new-array p3, v0, [Ljava/lang/String;

    const-string v0, "id"

    const/4 v1, 0x0

    aput-object v0, p3, v1

    const-string v0, "name"

    const/4 v1, 0x1

    aput-object v0, p3, v1

    .line 260
    invoke-static {p3}, Ljava/util/Arrays;->asList([Ljava/lang/Object;)Ljava/util/List;

    move-result-object v0

    invoke-interface {p2, v0}, Ljava/util/Set;->addAll(Ljava/util/Collection;)Z

    .line 262
    iget-object v0, p0, Lcom/facebook/widget/FriendPickerFragment;->adapter:Lcom/facebook/widget/GraphObjectAdapter;

    invoke-virtual {v0}, Lcom/facebook/widget/GraphObjectAdapter;->getPictureFieldSpecifier()Ljava/lang/String;

    move-result-object v0

    .line 263
    move-object p3, v0

    if-eqz v0, :cond_0

    .line 264
    invoke-interface {p2, p3}, Ljava/util/Set;->add(Ljava/lang/Object;)Z

    .line 267
    :cond_0
    invoke-virtual {p1}, Lcom/facebook/Request;->getParameters()Landroid/os/Bundle;

    move-result-object v0

    .line 268
    move-object p3, v0

    const-string v1, "fields"

    const-string v2, ","

    invoke-static {v2, p2}, Landroid/text/TextUtils;->join(Ljava/lang/CharSequence;Ljava/lang/Iterable;)Ljava/lang/String;

    move-result-object v2

    invoke-virtual {v0, v1, v2}, Landroid/os/Bundle;->putString(Ljava/lang/String;Ljava/lang/String;)V

    .line 269
    invoke-virtual {p1, p3}, Lcom/facebook/Request;->setParameters(Landroid/os/Bundle;)V

    .line 271
    return-object p1
.end method

.method private setFriendPickerSettingsFromBundle(Landroid/os/Bundle;)V
    .locals 2

    .line 276
    if-eqz p1, :cond_1

    .line 277
    const-string v0, "com.facebook.widget.FriendPickerFragment.UserId"

    invoke-virtual {p1, v0}, Landroid/os/Bundle;->containsKey(Ljava/lang/String;)Z

    move-result v0

    if-eqz v0, :cond_0

    .line 278
    const-string v0, "com.facebook.widget.FriendPickerFragment.UserId"

    invoke-virtual {p1, v0}, Landroid/os/Bundle;->getString(Ljava/lang/String;)Ljava/lang/String;

    move-result-object v0

    invoke-virtual {p0, v0}, Lcom/facebook/widget/FriendPickerFragment;->setUserId(Ljava/lang/String;)V

    .line 280
    :cond_0
    const-string v0, "com.facebook.widget.FriendPickerFragment.MultiSelect"

    iget-boolean v1, p0, Lcom/facebook/widget/FriendPickerFragment;->multiSelect:Z

    invoke-virtual {p1, v0, v1}, Landroid/os/Bundle;->getBoolean(Ljava/lang/String;Z)Z

    move-result v0

    invoke-virtual {p0, v0}, Lcom/facebook/widget/FriendPickerFragment;->setMultiSelect(Z)V

    .line 282
    :cond_1
    return-void
.end method

# virtual methods
.method createAdapter()Lcom/facebook/widget/PickerFragment$PickerFragmentAdapter;
    .locals 4
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "()Lcom/facebook/widget/PickerFragment<Lcom/facebook/model/GraphUser;>.PickerFragmentAdapter<Lcom/facebook/model/GraphUser;>;"
        }
    .end annotation

    .line 183
    new-instance v0, Lcom/facebook/widget/FriendPickerFragment$1;

    invoke-virtual {p0}, Lcom/facebook/widget/FriendPickerFragment;->getActivity()Lo/ˎ;

    move-result-object v1

    invoke-direct {v0, p0, v1}, Lcom/facebook/widget/FriendPickerFragment$1;-><init>(Lcom/facebook/widget/FriendPickerFragment;Landroid/content/Context;)V

    .line 197
    move-object v3, v0

    const/4 v1, 0x1

    invoke-virtual {v0, v1}, Lcom/facebook/widget/PickerFragment$PickerFragmentAdapter;->setShowCheckbox(Z)V

    .line 198
    invoke-virtual {p0}, Lcom/facebook/widget/FriendPickerFragment;->getShowPictures()Z

    move-result v0

    invoke-virtual {v3, v0}, Lcom/facebook/widget/PickerFragment$PickerFragmentAdapter;->setShowPicture(Z)V

    .line 199
    const/4 v0, 0x1

    new-array v0, v0, [Ljava/lang/String;

    const-string v1, "name"

    const/4 v2, 0x0

    aput-object v1, v0, v2

    invoke-static {v0}, Ljava/util/Arrays;->asList([Ljava/lang/Object;)Ljava/util/List;

    move-result-object v0

    invoke-virtual {v3, v0}, Lcom/facebook/widget/PickerFragment$PickerFragmentAdapter;->setSortFields(Ljava/util/List;)V

    .line 200
    const-string v0, "name"

    invoke-virtual {v3, v0}, Lcom/facebook/widget/PickerFragment$PickerFragmentAdapter;->setGroupByField(Ljava/lang/String;)V

    .line 202
    return-object v3
.end method

.method createLoadingStrategy()Lcom/facebook/widget/PickerFragment$LoadingStrategy;
    .locals 2
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "()Lcom/facebook/widget/PickerFragment<Lcom/facebook/model/GraphUser;>.LoadingStrategy;"
        }
    .end annotation

    .line 207
    new-instance v0, Lcom/facebook/widget/FriendPickerFragment$ImmediateLoadingStrategy;

    const/4 v1, 0x0

    invoke-direct {v0, p0, v1}, Lcom/facebook/widget/FriendPickerFragment$ImmediateLoadingStrategy;-><init>(Lcom/facebook/widget/FriendPickerFragment;Lcom/facebook/widget/FriendPickerFragment$1;)V

    return-object v0
.end method

.method createSelectionStrategy()Lcom/facebook/widget/PickerFragment$SelectionStrategy;
    .locals 1
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "()Lcom/facebook/widget/PickerFragment<Lcom/facebook/model/GraphUser;>.SelectionStrategy;"
        }
    .end annotation

    .line 212
    iget-boolean v0, p0, Lcom/facebook/widget/FriendPickerFragment;->multiSelect:Z

    if-eqz v0, :cond_0

    new-instance v0, Lcom/facebook/widget/PickerFragment$MultiSelectionStrategy;

    invoke-direct {v0, p0}, Lcom/facebook/widget/PickerFragment$MultiSelectionStrategy;-><init>(Lcom/facebook/widget/PickerFragment;)V

    return-object v0

    :cond_0
    new-instance v0, Lcom/facebook/widget/PickerFragment$SingleSelectionStrategy;

    invoke-direct {v0, p0}, Lcom/facebook/widget/PickerFragment$SingleSelectionStrategy;-><init>(Lcom/facebook/widget/PickerFragment;)V

    return-object v0
.end method

.method getDefaultTitleText()Ljava/lang/String;
    .locals 1

    .line 227
    sget v0, Lcom/facebook/android/R$string;->com_facebook_choose_friends:I

    invoke-virtual {p0, v0}, Lcom/facebook/widget/FriendPickerFragment;->getString(I)Ljava/lang/String;

    move-result-object v0

    return-object v0
.end method

.method public getMultiSelect()Z
    .locals 1

    .line 101
    iget-boolean v0, p0, Lcom/facebook/widget/FriendPickerFragment;->multiSelect:Z

    return v0
.end method

.method getRequestForLoadData(Lcom/facebook/Session;)Lcom/facebook/Request;
    .locals 3

    .line 217
    iget-object v0, p0, Lcom/facebook/widget/FriendPickerFragment;->adapter:Lcom/facebook/widget/GraphObjectAdapter;

    if-nez v0, :cond_0

    .line 218
    new-instance v0, Lcom/facebook/FacebookException;

    const-string v1, "Can\'t issue requests until Fragment has been created."

    invoke-direct {v0, v1}, Lcom/facebook/FacebookException;-><init>(Ljava/lang/String;)V

    throw v0

    .line 221
    :cond_0
    iget-object v0, p0, Lcom/facebook/widget/FriendPickerFragment;->userId:Ljava/lang/String;

    if-eqz v0, :cond_1

    iget-object v2, p0, Lcom/facebook/widget/FriendPickerFragment;->userId:Ljava/lang/String;

    goto :goto_0

    :cond_1
    const-string v2, "me"

    .line 222
    :goto_0
    iget-object v0, p0, Lcom/facebook/widget/FriendPickerFragment;->extraFields:Ljava/util/HashSet;

    invoke-direct {p0, v2, v0, p1}, Lcom/facebook/widget/FriendPickerFragment;->createRequest(Ljava/lang/String;Ljava/util/Set;Lcom/facebook/Session;)Lcom/facebook/Request;

    move-result-object v0

    return-object v0
.end method

.method public getSelection()Ljava/util/List;
    .locals 1
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "()Ljava/util/List<Lcom/facebook/model/GraphUser;>;"
        }
    .end annotation

    .line 156
    invoke-virtual {p0}, Lcom/facebook/widget/FriendPickerFragment;->getSelectedGraphObjects()Ljava/util/List;

    move-result-object v0

    return-object v0
.end method

.method public getUserId()Ljava/lang/String;
    .locals 1

    .line 84
    iget-object v0, p0, Lcom/facebook/widget/FriendPickerFragment;->userId:Ljava/lang/String;

    return-object v0
.end method

.method public loadData(Z)V
    .locals 1

    .line 248
    invoke-super {p0, p1}, Lcom/facebook/widget/PickerFragment;->loadData(Z)V

    .line 249
    iget-object v0, p0, Lcom/facebook/widget/FriendPickerFragment;->preSelectedFriendIds:Ljava/util/List;

    invoke-virtual {p0, v0}, Lcom/facebook/widget/FriendPickerFragment;->setSelectedGraphObjects(Ljava/util/List;)V

    .line 250
    return-void
.end method

.method logAppEvents(Z)V
    .locals 4

    .line 232
    invoke-virtual {p0}, Lcom/facebook/widget/FriendPickerFragment;->getActivity()Lo/ˎ;

    move-result-object v0

    invoke-virtual {p0}, Lcom/facebook/widget/FriendPickerFragment;->getSession()Lcom/facebook/Session;

    move-result-object v1

    invoke-static {v0, v1}, Lcom/facebook/AppEventsLogger;->newLogger(Landroid/content/Context;Lcom/facebook/Session;)Lcom/facebook/AppEventsLogger;

    move-result-object v2

    .line 233
    new-instance v3, Landroid/os/Bundle;

    invoke-direct {v3}, Landroid/os/Bundle;-><init>()V

    .line 238
    if-eqz p1, :cond_0

    const-string p1, "Completed"

    goto :goto_0

    :cond_0
    const-string p1, "Unknown"

    .line 240
    :goto_0
    const-string v0, "fb_dialog_outcome"

    invoke-virtual {v3, v0, p1}, Landroid/os/Bundle;->putString(Ljava/lang/String;Ljava/lang/String;)V

    .line 241
    const-string v0, "num_friends_picked"

    invoke-virtual {p0}, Lcom/facebook/widget/FriendPickerFragment;->getSelection()Ljava/util/List;

    move-result-object v1

    invoke-interface {v1}, Ljava/util/List;->size()I

    move-result v1

    invoke-virtual {v3, v0, v1}, Landroid/os/Bundle;->putInt(Ljava/lang/String;I)V

    .line 243
    const-string v0, "fb_friend_picker_usage"

    const/4 v1, 0x0

    invoke-virtual {v2, v0, v1, v3}, Lcom/facebook/AppEventsLogger;->logSdkEvent(Ljava/lang/String;Ljava/lang/Double;Landroid/os/Bundle;)V

    .line 244
    return-void
.end method

.method public onInflate(Landroid/app/Activity;Landroid/util/AttributeSet;Landroid/os/Bundle;)V
    .locals 2

    .line 161
    invoke-super {p0, p1, p2, p3}, Lcom/facebook/widget/PickerFragment;->onInflate(Landroid/app/Activity;Landroid/util/AttributeSet;Landroid/os/Bundle;)V

    .line 162
    sget-object v0, Lcom/facebook/android/R$styleable;->com_facebook_friend_picker_fragment:[I

    invoke-virtual {p1, p2, v0}, Landroid/app/Activity;->obtainStyledAttributes(Landroid/util/AttributeSet;[I)Landroid/content/res/TypedArray;

    move-result-object p1

    .line 164
    iget-boolean v0, p0, Lcom/facebook/widget/FriendPickerFragment;->multiSelect:Z

    const/4 v1, 0x0

    invoke-virtual {p1, v1, v0}, Landroid/content/res/TypedArray;->getBoolean(IZ)Z

    move-result v0

    invoke-virtual {p0, v0}, Lcom/facebook/widget/FriendPickerFragment;->setMultiSelect(Z)V

    .line 166
    invoke-virtual {p1}, Landroid/content/res/TypedArray;->recycle()V

    .line 167
    return-void
.end method

.method saveSettingsToBundle(Landroid/os/Bundle;)V
    .locals 2

    .line 175
    invoke-super {p0, p1}, Lcom/facebook/widget/PickerFragment;->saveSettingsToBundle(Landroid/os/Bundle;)V

    .line 177
    const-string v0, "com.facebook.widget.FriendPickerFragment.UserId"

    iget-object v1, p0, Lcom/facebook/widget/FriendPickerFragment;->userId:Ljava/lang/String;

    invoke-virtual {p1, v0, v1}, Landroid/os/Bundle;->putString(Ljava/lang/String;Ljava/lang/String;)V

    .line 178
    const-string v0, "com.facebook.widget.FriendPickerFragment.MultiSelect"

    iget-boolean v1, p0, Lcom/facebook/widget/FriendPickerFragment;->multiSelect:Z

    invoke-virtual {p1, v0, v1}, Landroid/os/Bundle;->putBoolean(Ljava/lang/String;Z)V

    .line 179
    return-void
.end method

.method public setMultiSelect(Z)V
    .locals 1

    .line 109
    iget-boolean v0, p0, Lcom/facebook/widget/FriendPickerFragment;->multiSelect:Z

    if-eq v0, p1, :cond_0

    .line 110
    iput-boolean p1, p0, Lcom/facebook/widget/FriendPickerFragment;->multiSelect:Z

    .line 111
    invoke-virtual {p0}, Lcom/facebook/widget/FriendPickerFragment;->createSelectionStrategy()Lcom/facebook/widget/PickerFragment$SelectionStrategy;

    move-result-object v0

    invoke-virtual {p0, v0}, Lcom/facebook/widget/FriendPickerFragment;->setSelectionStrategy(Lcom/facebook/widget/PickerFragment$SelectionStrategy;)V

    .line 113
    :cond_0
    return-void
.end method

.method public setSelection(Ljava/util/List;)V
    .locals 3
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "(Ljava/util/List<Lcom/facebook/model/GraphUser;>;)V"
        }
    .end annotation

    .line 144
    new-instance v1, Ljava/util/ArrayList;

    invoke-direct {v1}, Ljava/util/ArrayList;-><init>()V

    .line 145
    invoke-interface {p1}, Ljava/util/List;->iterator()Ljava/util/Iterator;

    move-result-object p1

    :goto_0
    invoke-interface {p1}, Ljava/util/Iterator;->hasNext()Z

    move-result v0

    if-eqz v0, :cond_0

    invoke-interface {p1}, Ljava/util/Iterator;->next()Ljava/lang/Object;

    move-result-object v0

    check-cast v0, Lcom/facebook/model/GraphUser;

    move-object v2, v0

    .line 146
    invoke-interface {v2}, Lcom/facebook/model/GraphUser;->getId()Ljava/lang/String;

    move-result-object v0

    invoke-interface {v1, v0}, Ljava/util/List;->add(Ljava/lang/Object;)Z

    .line 147
    goto :goto_0

    .line 148
    :cond_0
    invoke-virtual {p0, v1}, Lcom/facebook/widget/FriendPickerFragment;->setSelectionByIds(Ljava/util/List;)V

    .line 149
    return-void
.end method

.method public varargs setSelection([Lcom/facebook/model/GraphUser;)V
    .locals 1

    .line 136
    invoke-static {p1}, Ljava/util/Arrays;->asList([Ljava/lang/Object;)Ljava/util/List;

    move-result-object v0

    invoke-virtual {p0, v0}, Lcom/facebook/widget/FriendPickerFragment;->setSelection(Ljava/util/List;)V

    .line 137
    return-void
.end method

.method public setSelectionByIds(Ljava/util/List;)V
    .locals 1
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "(Ljava/util/List<Ljava/lang/String;>;)V"
        }
    .end annotation

    .line 120
    iget-object v0, p0, Lcom/facebook/widget/FriendPickerFragment;->preSelectedFriendIds:Ljava/util/List;

    invoke-interface {v0, p1}, Ljava/util/List;->addAll(Ljava/util/Collection;)Z

    .line 121
    return-void
.end method

.method public varargs setSelectionByIds([Ljava/lang/String;)V
    .locals 1

    .line 128
    invoke-static {p1}, Ljava/util/Arrays;->asList([Ljava/lang/Object;)Ljava/util/List;

    move-result-object v0

    invoke-virtual {p0, v0}, Lcom/facebook/widget/FriendPickerFragment;->setSelectionByIds(Ljava/util/List;)V

    .line 129
    return-void
.end method

.method public setSettingsFromBundle(Landroid/os/Bundle;)V
    .locals 0

    .line 170
    invoke-super {p0, p1}, Lcom/facebook/widget/PickerFragment;->setSettingsFromBundle(Landroid/os/Bundle;)V

    .line 171
    invoke-direct {p0, p1}, Lcom/facebook/widget/FriendPickerFragment;->setFriendPickerSettingsFromBundle(Landroid/os/Bundle;)V

    .line 172
    return-void
.end method

.method public setUserId(Ljava/lang/String;)V
    .locals 0

    .line 93
    iput-object p1, p0, Lcom/facebook/widget/FriendPickerFragment;->userId:Ljava/lang/String;

    .line 94
    return-void
.end method


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<title>More examples with monad transformers</title>

	Prev: Anatomy of a monad transformer
	TOC: Contents
	Next: Managing the transformer stack

More examples with monad transformers

WriterT with IO

ReaderT with IO

StateT with List

At this point, you should know everything you need to begin using monads and
monad transformers in your programs.  The best way to build proficiency is to work
on actual code.  As your monadic programs become more abitious, you may find
it awkward to mix additional transformers into your combined monads.  This will be
addressed in the next section, but first you should master the basic process of
applying a single transformer to a base monad.

WriterT with IO

Try adapting the firewall simulator of
example 17 to include a timestamp on each log entry (don't worry about merging entries).
The necessary changes should look something like this:

Code available in example22.hs

-- this is the format of our log entries
data Entry = Log {timestamp::ClockTime, msg::String} deriving Eq

instance Show Entry where
  show (Log t s) = (show t) ++ " | " ++ s

-- this is the combined monad type
type LogWriter a = WriterT [Entry] IO a

-- add a message to the log
logMsg :: String -> LogWriter ()
logMsg s = do t <- liftIO getClockTime
              tell [Log t s]

-- this handles one packet
filterOne :: [Rule] -> Packet -> LogWriter (Maybe Packet)
filterOne rules packet = do rule <- return (match rules packet)
                            case rule of
                              Nothing  -> do logMsg ("DROPPING UNMATCHED PACKET: " ++ (show packet))
                                             return Nothing
                              (Just r) -> do when (logIt r) (logMsg ("MATCH: " ++ (show r) ++ " <=> " ++ (show packet)))
                                             case r of
                                               (Rule Accept _ _) -> return (Just packet)
                                               (Rule Reject _ _) -> return Nothing

-- this filters a list of packets, producing a filtered packet list
-- and a log of the activity
filterAll :: [Rule] -> [Packet] -> LogWriter [Packet]
filterAll rules packets = do logMsg "STARTING PACKET FILTER"
                             out <- mapM (filterOne rules) packets
                             logMsg "STOPPING PACKET FILTER"
                             return (catMaybes out)

-- read the rule data from the file named in the first argument, and the packet data from
-- the file named in the second argument, and then print the accepted packets followed by
-- a log generated during the computation.
main :: IO ()
main = do args       <- getArgs
          ruleData   <- readFile (args!!0)
          packetData <- readFile (args!!1)
          let rules   = (read ruleData)::[Rule]
              packets = (read packetData)::[Packet]
          (out,log) <- runWriterT (filterAll rules packets)
          putStrLn "ACCEPTED PACKETS"
          putStr (unlines (map show out))
          putStrLn "\n\nFIREWALL LOG"
          putStr (unlines (map show log))

ReaderT with IO

If you found that one too easy, move on to a slightly more complex example:
convert the template system
in example 16 from using a single template file with named templates to
treating individual files as templates.  One possible solution is shown
in example 23, but try to do it without
looking first.

StateT with List

The previous examples have all been using the IO monad as the inner monad.
Here is a more interesting example: combining StateT with the
List monad to produce a monad for stateful nondeterministic computations.

We will apply this powerful monad combination to the task of solving
constraint satisfaction problems (in this case, a logic problem).  The idea
behind it is to have a number of variables that can take on different values
and a number of predicates involving those variables that must be satisfied.
The current variable assignments and the predicates make up the state of the
computation, and the non-deterministic nature of the List monad allows us to
easily test all combinations of variable assignments.

We start by laying the groundwork we will need to represent the logic
problem, a simple predicate language:

Code available in example24.hs

-- First, we develop a language to express logic problems
type Var   = String
type Value = String
data Predicate = Is    Var Value            -- var has specific value
               | Equal Var Var              -- vars have same (unspecified) value
	       | And   Predicate Predicate  -- both are true
	       | Or    Predicate Predicate  -- at least one is true
	       | Not   Predicate            -- it is not true
  deriving (Eq, Show)

type Variables = [(Var,Value)]

-- test for a variable NOT equaling a value
isNot :: Var -> Value -> Predicate
isNot var value = Not (Is var value)

-- if a is true, then b must also be true
implies :: Predicate -> Predicate -> Predicate
implies a b = Not (a `And` (Not b))

-- exclusive or
orElse :: Predicate -> Predicate -> Predicate
orElse a b = (a `And` (Not b)) `Or` ((Not a) `And` b)

-- Check a predicate with the given variable bindings.
-- An unbound variable causes a Nothing return value.
check :: Predicate -> Variables -> Maybe Bool
check (Is var value) vars = do val <- lookup var vars
                               return (val == value)
check (Equal v1 v2)  vars = do val1 <- lookup v1 vars
                               val2 <- lookup v2 vars
			       return (val1 == val2)
check (And p1 p2)    vars = liftM2 (&&) (check p1 vars) (check p2 vars)
check (Or  p1 p2)    vars = liftM2 (||) (check p1 vars) (check p2 vars)
check (Not p)        vars = liftM (not) (check p vars)

The next thing we will need is some code for representing and solving
constraint satisfaction problems.  This is where we will define our
combined monad.

Code available in example24.hs

-- this is the type of our logic problem
data ProblemState = PS {vars::Variables, constraints::[Predicate]}

-- this is our monad type for non-determinstic computations with state
type NDS a = StateT ProblemState [] a

-- lookup a variable
getVar :: Var -> NDS (Maybe Value)
getVar v = do vs <- gets vars
              return $ lookup v vs

-- set a variable
setVar :: Var -> Value -> NDS ()
setVar v x = do st <- get
                vs' <- return $ filter ((v/=).fst) (vars st)
                put $ st {vars=(v,x):vs'}

-- Check if the variable assignments satisfy all of the predicates.
-- The partial argument determines the value used when a predicate returns
-- Nothing because some variable it uses is not set.  Setting this to True
-- allows us to accept partial solutions, then we can use a value of
-- False at the end to signify that all solutions should be complete.
isConsistent :: Bool -> NDS Bool
isConsistent partial = do cs <- gets constraints
                          vs <- gets vars
                          let results = map (\p->check p vs) cs
                          return $ and (map (maybe partial id) results)

-- Return only the variable bindings that are complete consistent solutions.
getFinalVars :: NDS Variables
getFinalVars = do c <- isConsistent False
                  guard c
                  gets vars

-- Get the first solution to the problem, by evaluating the solver computation with
-- an initial problem state and then returning the first solution in the result list,
-- or Nothing if there was no solution.
getSolution :: NDS a -> ProblemState -> Maybe a
getSolution c i = listToMaybe (evalStateT c i)

-- Get a list of all possible solutions to the problem by evaluating the solver
-- computation with an initial problem state.
getAllSolutions :: NDS a -> ProblemState -> [a]
getAllSolutions c i = evalStateT c i

We are ready to apply the predicate language and stateful nondeterministic monad
to solving a logic problem.  For this example, we will use the well-known Kalotan
puzzle which appeared in Mathematical Brain-Teasers, Dover Publications (1976),
by J. A. H. Hunter.

The Kalotans are a tribe with a peculiar quirk: their males always tell the truth.
Their females never make two consecutive true statements, or two consecutive untrue
statements.

An anthropologist (let's call him Worf) has begun to study them. Worf does not yet
know the Kalotan language. One day, he meets a Kalotan (heterosexual) couple and
their child Kibi. Worf asks Kibi: ``Are you a boy?'' The kid answers in Kalotan,
which of course Worf doesn't understand.

Worf turns to the parents (who know English) for explanation. One of them says:
"Kibi said: `I am a boy.'" The other adds: "Kibi is a girl. Kibi lied."

Solve for the sex of Kibi and the sex of each parent.

We will need some additional predicates specific to this puzzle, and to define
the universe of allowed variables values:

Code available in example24.hs

-- if a male says something, it must be true
said :: Var -> Predicate -> Predicate
said v p = (v `Is` "male") `implies` p

-- if a male says two things, they must be true
-- if a female says two things, one must be true and one must be false
saidBoth :: Var -> Predicate -> Predicate -> Predicate
saidBoth v p1 p2 = And ((v `Is` "male") `implies` (p1 `And` p2))
                       ((v `Is` "female") `implies` (p1 `orElse` p2))

-- lying is saying something is true when it isn't or saying something isn't true when it is
lied :: Var -> Predicate -> Predicate
lied v p = ((v `said` p) `And` (Not p)) `orElse` ((v `said` (Not p)) `And` p)

-- Test consistency over all allowed settings of the variable.
tryAllValues :: Var -> NDS ()
tryAllValues var = do (setVar var "male") `mplus` (setVar var "female")
                      c <- isConsistent True
                      guard c

All that remains to be done is to define the puzzle in the predicate
language and get a solution that satisfies all of the predicates:

Code available in example24.hs

-- Define the problem, try all of the variable assignments and print a solution.
main :: IO ()
main = do let variables   = []
              constraints = [ Not (Equal "parent1" "parent2"),
                              "parent1" `said` ("child" `said` ("child" `Is` "male")),
                              saidBoth "parent2" ("child" `Is` "female")
                                                 ("child" `lied` ("child" `Is` "male")) ]
              problem     = PS variables constraints
          print $ (`getSolution` problem) $ do tryAllValues "parent1"
                                               tryAllValues "parent2"
                                               tryAllValues "child"
                                               getFinalVars

Each call to tryAllValues will fork the solution space,
assigning the named variable to be "male" in one fork and
"female" in the other.  The forks which produce inconsistent
variable assignments are eliminated (using the guard function).
The call to getFinalVars applies guard again to
eliminate inconsistent variable assignments and returns the remaining
assignments as the value of the computation.

	Prev: Anatomy of a monad transformer
	TOC: Contents
	Next: Managing the transformer stack


text:
export * from './golfclub.component';
export * from './golfclub-list/golfclub-list.component';
export * from './golfclub-routing.module';
export * from './golfclub.module';


text:
package org.multibit.viewsystem.swing.action;

import javax.swing.AbstractAction;
import org.multibit.controller.Controller;
import org.multibit.viewsystem.swing.view.panels.HelpContentsPanel;

/**
 *
 * @author Cameron Garnham
 */
public abstract class AbstractExitAction extends AbstractAction {
    protected final Controller controller;

    public AbstractExitAction(Controller controller) {
        super(controller.getLocaliser().getString("exitAction.text"));
        this.controller = controller;

        MnemonicUtil mnemonicUtil = new MnemonicUtil(this.controller.getLocaliser());
        putValue(SHORT_DESCRIPTION, HelpContentsPanel.createTooltipTextForMenuItem(this.controller.getLocaliser().getString("exitAction.tooltip")));
        putValue(MNEMONIC_KEY, mnemonicUtil.getMnemonic("exitAction.mnemonicKey"));
    }

}


text:
#include "sys_sys_types.h"
#include "LOG_bridge.h"
#include "POP_bridge.h"
#include "T_bridge.h"
#include "ooaofooa_classes.h"

/*
 * Instance Loader (from string data).
 */
Escher_iHandle_t
ooaofooa_I_LNK_instanceloader( Escher_iHandle_t instance, const c_t * avlstring[] )
{
  Escher_iHandle_t return_identifier = 0;
  ooaofooa_I_LNK * self = (ooaofooa_I_LNK *) instance;
  /* Initialize application analysis class attributes.  */
  self->Link_ID = (Escher_iHandle_t) Escher_atoi( avlstring[ 1 ] );
  return_identifier = self->Link_ID;
  self->Rel_ID = (Escher_iHandle_t) Escher_atoi( avlstring[ 2 ] );
  self->fromInst_ID = (Escher_iHandle_t) Escher_atoi( avlstring[ 3 ] );
  self->toInst_ID = (Escher_iHandle_t) Escher_atoi( avlstring[ 4 ] );
  self->assocInst_ID = (Escher_iHandle_t) Escher_atoi( avlstring[ 5 ] );
  return return_identifier;
}

/*
 * Select any where using referential/identifying attribute set.
 * If not_empty, relate this instance to the selected instance.
 */
void ooaofooa_I_LNK_batch_relate( Escher_iHandle_t instance )
{
  ooaofooa_I_LNK * ooaofooa_I_LNK_instance = (ooaofooa_I_LNK *) instance;
  ooaofooa_R_REL * ooaofooa_R_RELrelated_instance1 = ooaofooa_R_REL_AnyWhere1( ooaofooa_I_LNK_instance->Rel_ID );
  if ( ooaofooa_R_RELrelated_instance1 ) {
    ooaofooa_I_LNK_R2904_Link_has_instances( ooaofooa_R_RELrelated_instance1, ooaofooa_I_LNK_instance );
  }
  {
  ooaofooa_I_LIP * ooaofooa_I_LIPrelated_instance1 = ooaofooa_I_LIP_AnyWhere1( ooaofooa_I_LNK_instance->Rel_ID, ooaofooa_I_LNK_instance->fromInst_ID );
  if ( ooaofooa_I_LIPrelated_instance1 ) {
    ooaofooa_I_LNK_R2901_Link_is_origin_of( ooaofooa_I_LIPrelated_instance1, ooaofooa_I_LNK_instance );
  }
  }
  {
  ooaofooa_I_LIP * ooaofooa_I_LIPrelated_instance1 = ooaofooa_I_LIP_AnyWhere1( ooaofooa_I_LNK_instance->Rel_ID, ooaofooa_I_LNK_instance->toInst_ID );
  if ( ooaofooa_I_LIPrelated_instance1 ) {
    ooaofooa_I_LNK_R2902_Link_is_destination_of( ooaofooa_I_LIPrelated_instance1, ooaofooa_I_LNK_instance );
  }
  }
  {
  ooaofooa_I_LIP * ooaofooa_I_LIPrelated_instance1 = ooaofooa_I_LIP_AnyWhere1( ooaofooa_I_LNK_instance->Rel_ID, ooaofooa_I_LNK_instance->assocInst_ID );
  if ( ooaofooa_I_LIPrelated_instance1 ) {
    ooaofooa_I_LNK_R2903_Link_is_associator_for( ooaofooa_I_LIPrelated_instance1, ooaofooa_I_LNK_instance );
  }
  }
}

/*
 * RELATE I_LIP TO I_LNK ACROSS R2901
 */
void
ooaofooa_I_LNK_R2901_Link_is_origin_of( ooaofooa_I_LIP * part, ooaofooa_I_LNK * form )
{
  /* Use TagEmptyHandleDetectionOn() to detect empty handle references.  */
  form->fromInst_ID = part->Inst_ID;
  form->Rel_ID = part->Rel_ID;
  form->I_LIP_R2901_originates_at = part;
  Escher_SetInsertElement( &part->I_LNK_R2901_is_origin_of, (Escher_ObjectSet_s *) form );
}

/*
 * UNRELATE I_LIP FROM I_LNK ACROSS R2901
 */
void
ooaofooa_I_LNK_R2901_Unlink_is_origin_of( ooaofooa_I_LIP * part, ooaofooa_I_LNK * form )
{
  /* Use TagEmptyHandleDetectionOn() to detect empty handle references.  */
  form->fromInst_ID = 0;
  form->I_LIP_R2901_originates_at = 0;
  Escher_SetRemoveElement( &part->I_LNK_R2901_is_origin_of, (Escher_ObjectSet_s *) form );
}

/*
 * RELATE I_LIP TO I_LNK ACROSS R2902
 */
void
ooaofooa_I_LNK_R2902_Link_is_destination_of( ooaofooa_I_LIP * part, ooaofooa_I_LNK * form )
{
  /* Use TagEmptyHandleDetectionOn() to detect empty handle references.  */
  form->toInst_ID = part->Inst_ID;
  form->Rel_ID = part->Rel_ID;
  form->I_LIP_R2902_ends_at = part;
  Escher_SetInsertElement( &part->I_LNK_R2902_is_destination_of, (Escher_ObjectSet_s *) form );
}

/*
 * UNRELATE I_LIP FROM I_LNK ACROSS R2902
 */
void
ooaofooa_I_LNK_R2902_Unlink_is_destination_of( ooaofooa_I_LIP * part, ooaofooa_I_LNK * form )
{
  /* Use TagEmptyHandleDetectionOn() to detect empty handle references.  */
  form->toInst_ID = 0;
  form->I_LIP_R2902_ends_at = 0;
  Escher_SetRemoveElement( &part->I_LNK_R2902_is_destination_of, (Escher_ObjectSet_s *) form );
}

/*
 * RELATE I_LIP TO I_LNK ACROSS R2903
 */
void
ooaofooa_I_LNK_R2903_Link_is_associator_for( ooaofooa_I_LIP * part, ooaofooa_I_LNK * form )
{
  /* Use TagEmptyHandleDetectionOn() to detect empty handle references.  */
  form->assocInst_ID = part->Inst_ID;
  form->Rel_ID = part->Rel_ID;
  form->I_LIP_R2903_has_associator = part;
  Escher_SetInsertElement( &part->I_LNK_R2903_is_associator_for, (Escher_ObjectSet_s *) form );
}

/*
 * UNRELATE I_LIP FROM I_LNK ACROSS R2903
 */
void
ooaofooa_I_LNK_R2903_Unlink_is_associator_for( ooaofooa_I_LIP * part, ooaofooa_I_LNK * form )
{
  /* Use TagEmptyHandleDetectionOn() to detect empty handle references.  */
  form->assocInst_ID = 0;
  form->I_LIP_R2903_has_associator = 0;
  Escher_SetRemoveElement( &part->I_LNK_R2903_is_associator_for, (Escher_ObjectSet_s *) form );
}

/*
 * RELATE R_REL TO I_LNK ACROSS R2904
 */
void
ooaofooa_I_LNK_R2904_Link_has_instances( ooaofooa_R_REL * part, ooaofooa_I_LNK * form )
{
  /* Use TagEmptyHandleDetectionOn() to detect empty handle references.  */
  form->Rel_ID = part->Rel_ID;
  form->R_REL_R2904_is_instance_of = part;
  Escher_SetInsertElement( &part->I_LNK_R2904_has_instances, (Escher_ObjectSet_s *) form );
}

/*
 * UNRELATE R_REL FROM I_LNK ACROSS R2904
 */
void
ooaofooa_I_LNK_R2904_Unlink_has_instances( ooaofooa_R_REL * part, ooaofooa_I_LNK * form )
{
  /* Use TagEmptyHandleDetectionOn() to detect empty handle references.  */
  form->R_REL_R2904_is_instance_of = 0;
  Escher_SetRemoveElement( &part->I_LNK_R2904_has_instances, (Escher_ObjectSet_s *) form );
}

/*
 * Dump instances in SQL format.
 */
void
ooaofooa_I_LNK_instancedumper( Escher_iHandle_t instance )
{
  ooaofooa_I_LNK * self = (ooaofooa_I_LNK *) instance;
  printf( "INSERT INTO I_LNK VALUES ( %ld,%ld,%ld,%ld,%ld );\n",
    ((long)self->Link_ID & ESCHER_IDDUMP_MASK),
    ((long)self->Rel_ID & ESCHER_IDDUMP_MASK),
    ((long)self->fromInst_ID & ESCHER_IDDUMP_MASK),
    ((long)self->toInst_ID & ESCHER_IDDUMP_MASK),
    ((long)self->assocInst_ID & ESCHER_IDDUMP_MASK) );
}
/*
 * Statically allocate space for the instance population for this class.
 * Allocate space for the class instance and its attribute values.
 * Depending upon the collection scheme, allocate containoids (collection
 * nodes) for gathering instances into free and active extents.
 */
static Escher_SetElement_s ooaofooa_I_LNK_container[ ooaofooa_I_LNK_MAX_EXTENT_SIZE ];
static ooaofooa_I_LNK ooaofooa_I_LNK_instances[ ooaofooa_I_LNK_MAX_EXTENT_SIZE ];
Escher_Extent_t pG_ooaofooa_I_LNK_extent = {
  {0,0}, {0,0}, &ooaofooa_I_LNK_container[ 0 ],
  (Escher_iHandle_t) &ooaofooa_I_LNK_instances,
  sizeof( ooaofooa_I_LNK ), 0, ooaofooa_I_LNK_MAX_EXTENT_SIZE
  };


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

    <groupId>com.d2lvalence</groupId>
    <artifactId>valence-sdk-java</artifactId>
    <version>1.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>valence-sdk-java</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.7</version>
            <type>jar</type>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
            <type>jar</type>
        </dependency>
    </dependencies>
</project>


text:
#include "config.h"
#include "EventTarget.h"

#include "Event.h"
#include "EventException.h"
#include "InspectorInstrumentation.h"
#include "ScriptController.h"
#include "WebKitTransitionEvent.h"
#include <wtf/MainThread.h>
#include <wtf/StdLibExtras.h>
#include <wtf/Vector.h>

using namespace WTF;

namespace WebCore {

EventTargetData::EventTargetData()
{
}

EventTargetData::~EventTargetData()
{
}

EventTarget::~EventTarget()
{
}

Node* EventTarget::toNode()
{
    return 0;
}

DOMWindow* EventTarget::toDOMWindow()
{
    return 0;
}

bool EventTarget::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
{
    EventTargetData* d = ensureEventTargetData();
    return d->eventListenerMap.add(eventType, listener, useCapture);
}

bool EventTarget::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
{
    EventTargetData* d = eventTargetData();
    if (!d)
        return false;

    size_t indexOfRemovedListener;

    if (!d->eventListenerMap.remove(eventType, listener, useCapture, indexOfRemovedListener))
        return false;

    // Notify firing events planning to invoke the listener at 'index' that
    // they have one less listener to invoke.
    if (!d->firingEventIterators)
        return true;
    for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
        FiringEventIterator& firingIterator = d->firingEventIterators->at(i);
        if (eventType != firingIterator.eventType)
            continue;

        if (indexOfRemovedListener >= firingIterator.end)
            continue;

        --firingIterator.end;
        if (indexOfRemovedListener <= firingIterator.iterator)
            --firingIterator.iterator;
    }

    return true;
}

bool EventTarget::setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
{
    clearAttributeEventListener(eventType);
    if (!listener)
        return false;
    return addEventListener(eventType, listener, false);
}

EventListener* EventTarget::getAttributeEventListener(const AtomicString& eventType)
{
    const EventListenerVector& entry = getEventListeners(eventType);
    for (size_t i = 0; i < entry.size(); ++i) {
        if (entry[i].listener->isAttribute())
            return entry[i].listener.get();
    }
    return 0;
}

bool EventTarget::clearAttributeEventListener(const AtomicString& eventType)
{
    EventListener* listener = getAttributeEventListener(eventType);
    if (!listener)
        return false;
    return removeEventListener(eventType, listener, false);
}

bool EventTarget::dispatchEvent(PassRefPtr<Event> event, ExceptionCode& ec)
{
    if (!event || event->type().isEmpty()) {
        ec = EventException::UNSPECIFIED_EVENT_TYPE_ERR;
        return false;
    }

    if (event->isBeingDispatched()) {
        ec = EventException::DISPATCH_REQUEST_ERR;
        return false;
    }

    if (!scriptExecutionContext())
        return false;

    return dispatchEvent(event);
}

bool EventTarget::dispatchEvent(PassRefPtr<Event> event)
{
    event->setTarget(this);
    event->setCurrentTarget(this);
    event->setEventPhase(Event::AT_TARGET);
    bool defaultPrevented = fireEventListeners(event.get());
    event->setEventPhase(0);
    return defaultPrevented;
}

void EventTarget::uncaughtExceptionInEventHandler()
{
}

static AtomicString prefixedType(const Event* event)
{
    if (event->type() == eventNames().transitionendEvent)
        return eventNames().webkitTransitionEndEvent;

    return emptyString();
}

bool EventTarget::fireEventListeners(Event* event)
{
    ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
    ASSERT(event && !event->type().isEmpty());

    EventTargetData* d = eventTargetData();
    if (!d)
        return true;

    EventListenerVector* listenerPrefixedVector = 0;
    AtomicString prefixedTypeName = prefixedType(event);
    if (!prefixedTypeName.isEmpty())
        listenerPrefixedVector = d->eventListenerMap.find(prefixedTypeName);

    EventListenerVector* listenerUnprefixedVector = d->eventListenerMap.find(event->type());

    if (listenerUnprefixedVector)
        fireEventListeners(event, d, *listenerUnprefixedVector);
    else if (listenerPrefixedVector) {
        AtomicString unprefixedTypeName = event->type();
        event->setType(prefixedTypeName);
        fireEventListeners(event, d, *listenerPrefixedVector);
        event->setType(unprefixedTypeName);
    }

    if (!prefixedTypeName.isEmpty()) {
        ScriptExecutionContext* context = scriptExecutionContext();
        if (context && context->isDocument()) {
            Document* document = toDocument(context);
            if (document->domWindow()) {
                if (listenerPrefixedVector)
                    if (listenerUnprefixedVector)
                        FeatureObserver::observe(document->domWindow(), FeatureObserver::PrefixedAndUnprefixedTransitionEndEvent);
                    else
                        FeatureObserver::observe(document->domWindow(), FeatureObserver::PrefixedTransitionEndEvent);
                else if (listenerUnprefixedVector)
                    FeatureObserver::observe(document->domWindow(), FeatureObserver::UnprefixedTransitionEndEvent);
            }
        }
    }

    return !event->defaultPrevented();
}

void EventTarget::fireEventListenersInternal(Event* event, EventTargetData* d, EventListenerVector& entry)
{
    RefPtr<EventTarget> protect = this;
    // Fire all listeners registered for this event. Don't fire listeners removed
    // during event dispatch. Also, don't fire event listeners added during event
    // dispatch. Conveniently, all new event listeners will be added after 'end',
    // so iterating to 'end' naturally excludes new event listeners.
    //

    bool userEventWasHandled = false;
    size_t i = 0;
    size_t end = entry.size();
    if (!d->firingEventIterators)
        d->firingEventIterators = adoptPtr(new FiringEventIteratorVector);
    d->firingEventIterators->append(FiringEventIterator(event->type(), i, end));
    for ( ; i < end; ++i) {
        RegisteredEventListener& registeredListener = entry[i];
        if (event->eventPhase() == Event::CAPTURING_PHASE && !registeredListener.useCapture)
            continue;
        if (event->eventPhase() == Event::BUBBLING_PHASE && registeredListener.useCapture)
            continue;

        // If stopImmediatePropagation has been called, we just break out immediately, without
        // handling any more events on this target.
        if (event->immediatePropagationStopped())
            break;

        ScriptExecutionContext* context = scriptExecutionContext();
        InspectorInstrumentationCookie cookie = InspectorInstrumentation::willHandleEvent(context, event);
        // To match Mozilla, the AT_TARGET phase fires both capturing and bubbling
        // event listeners, even though that violates some versions of the DOM spec.
        registeredListener.listener->handleEvent(context, event);
        if (!userEventWasHandled && ScriptController::processingUserGesture())
            userEventWasHandled = true;
        InspectorInstrumentation::didHandleEvent(cookie);
    }
    d->firingEventIterators->removeLast();
    if (userEventWasHandled) {
        ScriptExecutionContext* context = scriptExecutionContext();
        if (context && context->isDocument()) {
            Document* document = toDocument(context);
            document->resetLastHandledUserGestureTimestamp();
        }
    }
}

void EventTarget::fireEventListeners(Event* event, EventTargetData* d, EventListenerVector& entry)
{
    ScriptExecutionContext* context = scriptExecutionContext();
    incrementEventReference(event);
    if (!context->isDocument() ||
        context->toDocument()->page()->chrome().client()->fireEvent(event, d, &entry, this)) {
        ASSERT(context->isDocument());
        fireEventListenersInternal(event, d, entry);
        // Once consumed, we don't want people to use the event repeatedly.
        decrementEventReference(event);
        // Let us not use more memory than necessary
    }
}

const EventListenerVector& EventTarget::getEventListeners(const AtomicString& eventType)
{
    DEFINE_STATIC_LOCAL(EventListenerVector, emptyVector, ());

    EventTargetData* d = eventTargetData();
    if (!d)
        return emptyVector;

    EventListenerVector* listenerVector = d->eventListenerMap.find(eventType);
    if (!listenerVector)
        return emptyVector;

    return *listenerVector;
}

void EventTarget::removeAllEventListeners()
{
    EventTargetData* d = eventTargetData();
    if (!d)
        return;
    d->eventListenerMap.clear();

    // Notify firing events planning to invoke the listener at 'index' that
    // they have one less listener to invoke.
    if (d->firingEventIterators) {
        for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
            d->firingEventIterators->at(i).iterator = 0;
            d->firingEventIterators->at(i).end = 0;
        }
    }
}

void EventTarget::deliverEvent(EventTarget* target , Event* ev, EventTargetData* d, void* v)
{
    // Don't call this function without a handle, that is crazy.
    target->ref();
    ASSERT(target->m_pendingEvents.contains(ev));
    if (target->m_pendingEvents.contains(ev)) {
        if (ev->target()) {
            target->fireEventListenersInternal(ev, d, *(EventListenerVector*)v);
        }
        target->decrementEventReference(ev);
    }
    target->deref();
    // Once fired, get rid of the event.
}

} // namespace WebCore


text:
<?php
namespace AwinTest\DependencyInjection;

use AwinTest\DependencyInjection\TestCase;
use AwinTest\DependencyInjection\Fixtures\InterfaceTypeHinting\InterfaceInConstructorParamTypeHints;

class InterfaceTypeHintingTest extends TestCase
{
    public function testCanGetDependencyWithInterfaceInConstructorTypeHints()
    {
        // ARRANGE
        $dependencyClassname    = '\AwinTest\DependencyInjection\Fixtures\InterfaceTypeHinting\InterfaceInConstructorParamTypeHints';
        $subdependencyClassname = '\AwinTest\DependencyInjection\Fixtures\InterfaceTypeHinting\Implementation2';

        $this->injector->configureDependencyParamClass($dependencyClassname, 'param1', $subdependencyClassname);

        // ACT
        $result = $this->injector->get($dependencyClassname); /* @var $result InterfaceInConstructorParamTypeHints */

        // ASSERT
        $this->assertInstanceOf($dependencyClassname,    $result);
        $this->assertInstanceOf($subdependencyClassname, $result->param);
    }

    /**
     * @expectedException \Awin\DependencyInjection\Exception\BadDiInterfaceConfigurationException
     */
    public function testCannotSaveInvalidSubdependencyClass()
    {
        // ARRANGE
        $dependencyClassname       = '\AwinTest\DependencyInjection\Fixtures\InterfaceTypeHinting\InterfaceInConstructorParamTypeHints';
        $badSubdependencyClassname = '\AwinTest\DependencyInjection\Fixtures\InterfaceTypeHinting\DoesntImplementAnything';
        $this->injector->configureDependencyParamClass($dependencyClassname, 'param1', $badSubdependencyClassname);

        // ACT
        $this->injector->get($dependencyClassname);
    }
}


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

    <string name="yes">Ja</string>
    <string name="no">Nein</string>
    <string name="cancel">Abbrechen</string>
    <string name="cont">Fortfahren</string>
    <string name="login">Login</string>
    <string name="logout">Logout</string>

    <string name="menu_exit">Beenden</string>
    <string name="menu_about">Impressum</string>
    <string name="menu_help">Hilfe</string>
    <string name="menu_new_bookmark">Neue Verbindung</string>
    <string name="menu_app_settings">Einstellungen</string>

    <string name="menu_title_bookmark">Verbindung</string>
    <string name="menu_connect">Verbinden</string>
    <string name="menu_edit">Edit</string>
    <string name="menu_delete">Löschen</string>

    <string name="menu_sys_keyboard">Tastatur</string>
    <string name="menu_ext_keyboard">Funktionstasten</string>
    <string name="menu_touch_pointer">Touch Pointer</string>
    <string name="menu_home">home</string>
    <string name="menu_disconnect">Verbindung trennen</string>

    <string name="section_bookmarks">Manuelle Verbindungen</string>
    <string name="section_active_sessions">Aktive Sitzungen</string>

    <string name="search_hint">Mit Computer verbinden</string>

    <string name="list_placeholder_login">Login</string>
    <string name="list_placeholder_no_servers">Keine Server</string>
    <string name="list_placeholder_connecting">Verbinde …</string>
    <string name="list_placeholder_disconnecting">Trenne Verbundung …</string>
    <string name="list_placeholder_connection_error">Verbindung unterbrochen</string>
    <string name="list_placeholder_wrong_password">Falsches Passwort</string>
    <string name="list_placeholder_invalid_username">Ungültiger Benutzername</string>
    <string name="list_placeholder_add_bookmark">Verbindung hinzufügen</string>

    <string name="settings_cat_host">Host</string>
    <string name="settings_label">Label</string>
    <string name="settings_hostname">Host</string>
    <string name="settings_port">Port</string>
    <string name="settings_cat_credentials">Zugangsdaten</string>
    <string name="settings_credentials">Zugangsdaten</string>
    <string name="settings_username">Benutzername</string>
    <string name="settings_password">Passwort</string>
    <string name="settings_domain">Domäne</string>
    <string name="settings_cat_settings">Einstellungen</string>
    <string name="settings_screen">Bildschirm</string>
    <string name="settings_cat_screen">Bildschirm Einstellungen</string>
    <string name="settings_colors">Farben</string>
    <string-array name="colors_array">
        <item>High Color (16 Bit)</item>
        <item>True Color (24 Bit)</item>
        <item>Highest Quality (32 Bit)</item>
    </string-array>
    <string name="settings_resolution">Auflösung</string>
    <string name="resolution_automatic">automatisch</string>
    <string name="resolution_fit">an Bildschirm anpassen</string>
    <string name="resolution_custom">Benutzerdefiniert</string>
    <string-array name="resolutions_array">
        <item>automatisch</item>
        <item>an Bildschirm anpassen</item>
        <item>Benutzerdefiniert</item>
        <item>640x480</item>
        <item>720x480</item>
        <item>800x600</item>
        <item>1024x768</item>
        <item>1280x1024</item>
        <item>1440x900</item>
        <item>1920x1080</item>
        <item>1920x1200</item>
    </string-array>
    <string name="settings_width">Breite</string>
    <string name="settings_height">Höhe</string>
    <string name="settings_performance">Leistung</string>
    <string name="settings_cat_performance">Leistungseinstellungen</string>
    <string name="settings_perf_remotefx">RemoteFX</string>
    <string name="settings_perf_wallpaper">Desktop Hintergrund</string>
    <string name="settings_perf_font_smoothing">Kantenglättung</string>
    <string name="settings_perf_desktop_composition">Desktop Composition</string>
    <string name="settings_perf_full_window_drag">Zeige Fensterinhalt während</string>
    <string name="settings_perf_menu_animation">Menü Animation</string>
    <string name="settings_perf_theming">Visuelle Stile</string>
    <string name="settings_advanced">Erweitert</string>
    <string name="settings_cat_advanced">Erweiterte Einstellungen</string>
    <string name="settings_enable_3g_settings">3G Einstellungen</string>
    <string name="settings_screen_3g">3G Bildschirm</string>
    <string name="settings_performance_3g">3G Leistung</string>
    <string name="settings_cat_gateway">Gateway</string>
    <string name="settings_enable_gateway_settings">Aktiviere Gateway</string>
    <string name="settings_gateway_settings">Gateway Einstellungen</string>
    <string name="settings_redirect_sdcard">SDCard umleiten</string>
		<string name="settings_redirect_sound">Ton umleiten</string>
    <string-array name="redirect_sound_array">
        <item>Nicht abspielen</item>
        <item>Auf Server abspielen</item>
        <item>Auf Client abspielen</item>
    </string-array>
    <string name="settings_redirect_microphone">Mikrophon umleiten</string>
    <string name="settings_security">Sicherheit</string>
    <string-array name="security_array">
        <item>Automatisch</item>
        <item>RDP</item>
        <item>TLS</item>
        <item>NLA</item>
    </string-array>
    <string name="settings_remote_program">Remote Program</string>
    <string name="settings_work_dir">Arbeitsverzeichnis</string>
    <string name="settings_async_channel">Async channel</string>
    <string name="settings_async_transport">Async transport</string>
    <string name="settings_async_input">Async input</string>
    <string name="settings_async_update">Async update</string>
    <string name="settings_console_mode">Konsolenmodus</string>

    <string name="settings_password_present">*******</string>
    <string name="settings_password_empty">nicht gesetzt</string>
    <string name="settings_cat_ui">Benutzeroberfläche</string>
    <string name="settings_ui_hide_status_bar">verstecke Statusleiste</string>
    <string name="settings_ui_hide_zoom_controls">verstecke Zoom Tasten</string>
    <string name="settings_ui_swap_mouse_buttons">Vertausche Maustasten</string>
    <string name="settings_ui_invert_scrolling">Invertiere Bildlauf</string>
    <string name="settings_ui_auto_scroll_touchpointer">Touch Zeiger automatischer Bildlauf</string>
    <string name="settings_ui_ask_on_exit">Zeige Dialog beim Beenden</string>
    <string name="settings_cat_power">Energiesparen</string>
    <string name="settings_power_disconnect_timeout">Schließe ungenutzte Verbindungen</string>
    <string name="settings_cat_security">Sicherheit</string>
    <string name="settings_security_accept_certificates">Akzeptiere alle Zertifikate</string>
    <string name="settings_security_clear_certificate_cache">Lösche Zertifikat Cache</string>
    <string name="settings_description_after_minutes">Nach %1$d Minuten</string>
    <string name="settings_description_disabled">Deaktiviert</string>

    <string name="title_bookmark_settings">Verbindungseinstellungen</string>
    <string name="title_application_settings">Einstellungen</string>
    <string name="title_home">aFreeRDP - FreeRDP für Android</string>
    <string name="title_create_shortcut">RDP Verbindungen</string>
    <string name="title_help">Hilfe</string>
    <string name="title_about">Impressum</string>

    <string name="error_bookmark_incomplete_title">Verlassen ohne zu speichern?</string>
    <string name="error_bookmark_incomplete">Abbrechen um Einstellungen zu verwerfen\nFortfahren um weiter zu editieren</string>
    <string name="error_connection_failure">Konnte keine Verbindung zum Server herstellen!</string>

    <string name="info_capabilities_changed">Die Bildschirmeinstellungen mussten angepasst werden, da der Server die gewählten nicht unterstützt!</string>
    <string name="info_reset_success">Lösche Zertifikatcache!</string>
    <string name="info_reset_failed">Konnte Zertifikatcache nicht löschen!</string>

    <string name="dlg_title_verify_certificate">Prüfe Zertifikat</string>
    <string name="dlg_msg_verify_certificate">Die Identität des Servers konnte nicht geprüft werden. Trotzdem verbinden?</string>
    <string name="dlg_title_credentials">Bitte geben sie ihre Zugangsdaten ein:</string>
    <string name="dlg_title_create_shortcut">Verknüpfung erzeugen</string>
    <string name="dlg_msg_create_shortcut">Verknüpfungsname:</string>
    <string name="dlg_msg_connecting">Verbinden …</string>
    <string name="dlg_msg_logging_in">Einloggen …</string>
    <string name="dlg_title_about">Über aFreeRDP</string>
    <string name="dlg_title_create_bookmark_after_qc">Verbindungseinstellungen speichern?</string>
    <string name="dlg_msg_create_bookmark_after_qc">Die Verbindungseinstellungen wurden nicht gespeichert! Jetzt speichern?</string>
    <string name="dlg_title_save_bookmark">Verbindung speichern?</string>
    <string name="dlg_save_bookmark">Wollen sie alle Änderungen der Verbindungseinstelleungen speichern?</string>
    <string name="dlg_dont_show_again">Nicht noch einmal nachfragen</string>
    <string name="dlg_title_exit">Anwendung beenden?</string>
    <string name="dlg_msg_exit">Wollen sie die Anwendung wirklich beenden?</string>
    <string name="dlg_title_clear_cert_cache">Lösche Zertifikate?</string>
    <string name="dlg_msg_clear_cert_cache">Wollen sie wirklich alle gespeicherten Zertifikate löschen?</string>
    <string name="debug_level">Debug Stufe</string>
    <string name="settings_debug">Debug Einstellungen</string>
</resources>


text:
All URIs are relative to *http://klifs.vu-compmedchem.nl/api*

Method | HTTP request | Description
------------- | ------------- | -------------
[**ligandsListGet**](LigandsApi.md#ligandsListGet) | **GET** /ligands_list | Get all co-crystallized ligands optionally restricted to a set of kinase IDs
[**ligandsListStructuresGet**](LigandsApi.md#ligandsListStructuresGet) | **GET** /ligands_list_structures | Get all structures in complex with one of the provided ligand IDs

# **ligandsListGet**
> List<LigandDetails> ligandsListGet(kinaseID)

Get all co-crystallized ligands optionally restricted to a set of kinase IDs

The Ligands List endpoint returns a list of co-crystallized ligands in KLIFS optiontally restricted to a set of specific kinase IDs.

### Example
```java
// Import classes:
//import io.swagger.client.ApiException;
//import io.swagger.client.api.LigandsApi;

LigandsApi apiInstance = new LigandsApi();
List<Integer> kinaseID = Arrays.asList(56); // List<Integer> | ID(s) of the kinase(s) for which all structures are requested.
try {
    List<LigandDetails> result = apiInstance.ligandsListGet(kinaseID);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling LigandsApi#ligandsListGet");
    e.printStackTrace();
}
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **kinaseID** | [**List<Integer>**](Integer.md)| ID(s) of the kinase(s) for which all structures are requested. | [optional]

### Return type

[**List<LigandDetails>**](LigandDetails.md)

### Authorization

No authorization required

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

# **ligandsListStructuresGet**
> List<StructureDetails> ligandsListStructuresGet(ligandID)

Get all structures in complex with one of the provided ligand IDs

The Ligands Get Structures endpoint returns a list of monomers of crystal structures in KLIFS in complex with provided ligand IDs.

### Example
```java
// Import classes:
//import io.swagger.client.ApiException;
//import io.swagger.client.api.LigandsApi;

LigandsApi apiInstance = new LigandsApi();
List<Integer> ligandID = Arrays.asList(56); // List<Integer> | ID(s) of the ligand(s) for which all structures are requested.
try {
    List<StructureDetails> result = apiInstance.ligandsListStructuresGet(ligandID);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling LigandsApi#ligandsListStructuresGet");
    e.printStackTrace();
}
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **ligandID** | [**List<Integer>**](Integer.md)| ID(s) of the ligand(s) for which all structures are requested. |

### Return type

[**List<StructureDetails>**](StructureDetails.md)

### Authorization

No authorization required

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Non-lichenized Pyrenomycetes of Sweden (Lund) 7 (1992)

#### Original name
Teichospora juniperina K. Holm & L. Holm

### Remarks
null


text:
import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
import akka.http.scaladsl.marshalling.ToResponseMarshallable
import akka.http.scaladsl.model.StatusCodes._
import akka.http.scaladsl.server.Directives._
import akka.stream.ActorFlowMaterializer
import metrics.common.{Value, RequestResponseStats, Counter, Metrics}
import metrics.common.MetricsDirectives._

case class LoginRequest(identityId: Long, authMethod: String)

case class ReloginRequest(tokenValue: String, authMethod: String)

case class Token(value: String, validTo: Long, identityId: Long, authMethods: Set[String])

object TokenManager extends App with JsonProtocols with Config with Metrics {
  implicit val actorSystem = ActorSystem()
  implicit val materializer = ActorFlowMaterializer()
  implicit val dispatcher = actorSystem.dispatcher

  val repository = new Repository
  val service = new Service(repository)

  def putMetricForRequestResponse(requestStats: RequestResponseStats): Unit = {
    val method = requestStats.request.method.name.toLowerCase
    putMetric(Value(s"token-manager.$method.time", requestStats.time))
  }

  Http().bindAndHandle(interface = interface, port = port, handler = {
    (measureRequestResponse(putMetricForRequestResponse) & logRequestResult("token-manager")) {
      pathPrefix("tokens") {
        (post & pathEndOrSingleSlash & entity(as[LoginRequest])) { loginRequest =>
          complete {
            putMetric(Counter("token-manager.post", 1))
            service.login(loginRequest).map(token => Created -> token)
          }
        } ~
        (patch & pathEndOrSingleSlash & entity(as[ReloginRequest])) { reloginRequest =>
          complete {
            service.relogin(reloginRequest).map[ToResponseMarshallable] {
              case Some(token) =>
                putMetric(Counter("token-manager.patch", 1))
                OK -> token
              case None =>
                putMetric(Counter("token-manager.patch", -1))
                NotFound -> "Token expired or not found"
            }
          }
        } ~
        (path(Segment) & pathEndOrSingleSlash) { tokenValue =>
          get {
            complete {
              service.findAndRefreshToken(tokenValue).map[ToResponseMarshallable] {
                case Some(token) =>
                  putMetric(Counter("token-manager.get", 1))
                  OK -> token
                case None =>
                  putMetric(Counter("token-manager.get", -1))
                  NotFound -> "Token expired or not found"
              }
            }
          } ~
          delete {
            complete {
              service.logout(tokenValue)
              putMetric(Counter("token-manager.delete", 1))
              OK
            }
          }
        }
      }
    }
  })
}


text:
package br.org.catolicasc.rh.model;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlTransient;

import br.org.catolicasc.rh.model.Bean;

@Entity
@XmlAccessorType(XmlAccessType.FIELD)
public class Job implements Bean{

	@Id
	@GeneratedValue
	private Long id;

	private String company;
	private String city;
	@XmlTransient
	private Date resignationDate;
	@XmlTransient
	private Date initDate;
	private String performedActivities;

	public Job() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Job(Long id) {
		this();
		this.id = id;
	}

	public Job(String company, String city, Date resignationDate, Date initDate, String performedActivities) {
		this();
		this.company = company;
		this.city = city;
		this.resignationDate = resignationDate;
		this.initDate = initDate;
		this.performedActivities = performedActivities;
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getCompany() {
		return company;
	}
	public void setCompany(String company) {
		this.company = company;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public Date getResignationDate() {
		return resignationDate;
	}
	public void setResignationDate(Date resignationDate) {
		this.resignationDate = resignationDate;
	}
	public Date getInitDate() {
		return initDate;
	}
	public void setInitDate(Date initDate) {
		this.initDate = initDate;
	}
	public String getPerformedActivities() {
		return performedActivities;
	}
	public void setPerformedActivities(String performedActivities) {
		this.performedActivities = performedActivities;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((city == null) ? 0 : city.hashCode());
		result = prime * result + ((company == null) ? 0 : company.hashCode());
		result = prime * result + (int) (id ^ (id >>> 32));
		result = prime * result + ((initDate == null) ? 0 : initDate.hashCode());
		result = prime * result + ((performedActivities == null) ? 0 : performedActivities.hashCode());
		result = prime * result + ((resignationDate == null) ? 0 : resignationDate.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Job other = (Job) obj;
		if (city == null) {
			if (other.city != null)
				return false;
		} else if (!city.equals(other.city))
			return false;
		if (company == null) {
			if (other.company != null)
				return false;
		} else if (!company.equals(other.company))
			return false;
		if (id != other.id)
			return false;
		if (initDate == null) {
			if (other.initDate != null)
				return false;
		} else if (!initDate.equals(other.initDate))
			return false;
		if (performedActivities == null) {
			if (other.performedActivities != null)
				return false;
		} else if (!performedActivities.equals(other.performedActivities))
			return false;
		if (resignationDate == null) {
			if (other.resignationDate != null)
				return false;
		} else if (!resignationDate.equals(other.resignationDate))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Job [id=" + id + ", company=" + company + ", city=" + city + ", resignationDate=" + resignationDate
				+ ", initDate=" + initDate + ", performedActivities=" + performedActivities + "]";
	}

}


text:
**Advent of Code - Elixir**

Further bulletins as events warrant.


text:
import copy
import numpy as np
import unittest

import ray
import ray.rllib.agents.dqn as dqn
from ray.rllib.agents.dqn.dqn_tf_policy import _adjust_nstep
from ray.rllib.utils.test_utils import check, check_compute_single_action, \
    framework_iterator

class TestDQN(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        ray.init()

    @classmethod
    def tearDownClass(cls) -> None:
        ray.shutdown()

    def test_dqn_compilation(self):
        """Test whether a DQNTrainer can be built on all frameworks."""
        config = dqn.DEFAULT_CONFIG.copy()
        config["num_workers"] = 2
        num_iterations = 1

        for _ in framework_iterator(config):
            # Double-dueling DQN.
            print("Double-dueling")
            plain_config = config.copy()
            trainer = dqn.DQNTrainer(config=plain_config, env="CartPole-v0")
            for i in range(num_iterations):
                results = trainer.train()
                print(results)

            check_compute_single_action(trainer)
            trainer.stop()

            # Rainbow.
            print("Rainbow")
            rainbow_config = config.copy()
            rainbow_config["num_atoms"] = 10
            rainbow_config["noisy"] = True
            rainbow_config["double_q"] = True
            rainbow_config["dueling"] = True
            rainbow_config["n_step"] = 5
            trainer = dqn.DQNTrainer(config=rainbow_config, env="CartPole-v0")
            for i in range(num_iterations):
                results = trainer.train()
                print(results)

            check_compute_single_action(trainer)
            trainer.stop()

    def test_dqn_fake_multi_gpu_learning(self):
        """Test whether DQNTrainer can learn CartPole w/ faked multi-GPU."""
        config = copy.deepcopy(dqn.DEFAULT_CONFIG)

        # Fake GPU setup.
        config["num_gpus"] = 2
        config["_fake_gpus"] = True

        config["framework"] = "tf"
        # Double batch size (2 GPUs).
        config["train_batch_size"] = 64
        # Mimic tuned_example for DQN CartPole.
        config["n_step"] = 3
        config["model"]["fcnet_hiddens"] = [64]
        config["model"]["fcnet_activation"] = "linear"

        trainer = dqn.DQNTrainer(config=config, env="CartPole-v0")
        num_iterations = 200
        learnt = False
        for i in range(num_iterations):
            results = trainer.train()
            print("reward={}".format(results["episode_reward_mean"]))
            if results["episode_reward_mean"] > 100.0:
                learnt = True
                break
        assert learnt, "DQN multi-GPU (with fake-GPUs) did not learn CartPole!"
        trainer.stop()

    def test_dqn_n_step(self):
        obs = [1, 2, 3, 4, 5, 6, 7]
        actions = ["a", "b", "a", "a", "a", "b", "a"]
        rewards = [10.0, 0.0, 100.0, 100.0, 100.0, 100.0, 100.0]
        new_obs = [2, 3, 4, 5, 6, 7, 8]
        dones = [0, 0, 0, 0, 0, 0, 1]
        _adjust_nstep(3, 0.9, obs, actions, rewards, new_obs, dones)
        self.assertEqual(obs, [1, 2, 3, 4, 5, 6, 7])
        self.assertEqual(actions, ["a", "b", "a", "a", "a", "b", "a"])
        self.assertEqual(new_obs, [4, 5, 6, 7, 8, 8, 8])
        self.assertEqual(dones, [0, 0, 0, 0, 1, 1, 1])
        self.assertEqual(rewards,
                         [91.0, 171.0, 271.0, 271.0, 271.0, 190.0, 100.0])

    def test_dqn_exploration_and_soft_q_config(self):
        """Tests, whether a DQN Agent outputs exploration/softmaxed actions."""
        config = dqn.DEFAULT_CONFIG.copy()
        config["num_workers"] = 0  # Run locally.
        config["env_config"] = {"is_slippery": False, "map_name": "4x4"}
        obs = np.array(0)

        # Test against all frameworks.
        for _ in framework_iterator(config):
            # Default EpsilonGreedy setup.
            trainer = dqn.DQNTrainer(config=config, env="FrozenLake-v0")
            # Setting explore=False should always return the same action.
            a_ = trainer.compute_single_action(obs, explore=False)
            for _ in range(50):
                a = trainer.compute_single_action(obs, explore=False)
                check(a, a_)
            # explore=None (default: explore) should return different actions.
            actions = []
            for _ in range(50):
                actions.append(trainer.compute_single_action(obs))
            check(np.std(actions), 0.0, false=True)
            trainer.stop()

            # Low softmax temperature. Behaves like argmax
            # (but no epsilon exploration).
            config["exploration_config"] = {
                "type": "SoftQ",
                "temperature": 0.000001
            }
            trainer = dqn.DQNTrainer(config=config, env="FrozenLake-v0")
            # Due to the low temp, always expect the same action.
            actions = [trainer.compute_single_action(obs)]
            for _ in range(50):
                actions.append(trainer.compute_single_action(obs))
            check(np.std(actions), 0.0, decimals=3)
            trainer.stop()

            # Higher softmax temperature.
            config["exploration_config"]["temperature"] = 1.0
            trainer = dqn.DQNTrainer(config=config, env="FrozenLake-v0")

            # Even with the higher temperature, if we set explore=False, we
            # should expect the same actions always.
            a_ = trainer.compute_single_action(obs, explore=False)
            for _ in range(50):
                a = trainer.compute_single_action(obs, explore=False)
                check(a, a_)

            # Due to the higher temp, expect different actions avg'ing
            # around 1.5.
            actions = []
            for _ in range(300):
                actions.append(trainer.compute_single_action(obs))
            check(np.std(actions), 0.0, false=True)
            trainer.stop()

            # With Random exploration.
            config["exploration_config"] = {"type": "Random"}
            config["explore"] = True
            trainer = dqn.DQNTrainer(config=config, env="FrozenLake-v0")
            actions = []
            for _ in range(300):
                actions.append(trainer.compute_single_action(obs))
            check(np.std(actions), 0.0, false=True)
            trainer.stop()

if __name__ == "__main__":
    import pytest
    import sys
    sys.exit(pytest.main(["-v", __file__]))


text:
namespace google {
namespace cloud {
namespace storage_internal {
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
namespace {

namespace v2 = ::google::storage::v2;
using ::google::cloud::testing_util::IsProtoEqual;
using ::testing::ElementsAre;

TEST(GrpcNotificationRequestParser, DeleteNotification) {
  v2::DeleteNotificationRequest expected;
  ASSERT_TRUE(google::protobuf::TextFormat::ParseFromString(
      R"pb(
        name: "projects/_/buckets/test-bucket-name/notificationConfigs/test-notification-id"
      )pb",
      &expected));

  storage::internal::DeleteNotificationRequest req("test-bucket-name",
                                                   "test-notification-id");

  auto const actual = ToProto(req);
  EXPECT_THAT(actual, IsProtoEqual(expected));
}

TEST(GrpcNotificationRequestParser, GetNotification) {
  v2::GetNotificationRequest expected;
  ASSERT_TRUE(google::protobuf::TextFormat::ParseFromString(
      R"pb(
        name: "projects/_/buckets/test-bucket-name/notificationConfigs/test-notification-id"
      )pb",
      &expected));

  storage::internal::GetNotificationRequest req("test-bucket-name",
                                                "test-notification-id");

  auto const actual = ToProto(req);
  EXPECT_THAT(actual, IsProtoEqual(expected));
}

TEST(GrpcNotificationRequestParser, CreateNotification) {
  v2::CreateNotificationRequest expected;
  ASSERT_TRUE(google::protobuf::TextFormat::ParseFromString(
      R"pb(
        parent: "projects/_/buckets/test-bucket-name"
        notification {
          topic: "//pubsub.googleapis.com/projects/test-topic-project/topics/test-topic-id"
          event_types: "OBJECT_DELETE"
          event_types: "OBJECT_ARCHIVE"
          custom_attributes { key: "test-key-0" value: "test-value-0" }
          custom_attributes { key: "test-key-1" value: "test-value-1" }
          object_name_prefix: "test-object-name-prefix/"
          payload_format: "JSON_API_V1"
        }
      )pb",
      &expected));

  storage::internal::CreateNotificationRequest req(
      "test-bucket-name",
      storage::NotificationMetadata()
          .set_topic("projects/test-topic-project/topics/test-topic-id")
          .append_event_type("OBJECT_DELETE")
          .append_event_type("OBJECT_ARCHIVE")
          .upsert_custom_attributes("test-key-0", "test-value-0")
          .upsert_custom_attributes("test-key-1", "test-value-1")
          .set_object_name_prefix("test-object-name-prefix/")
          .set_payload_format("JSON_API_V1"));
  req.set_multiple_options(storage::UserProject("test-user-project"));

  auto const actual = ToProto(req);
  EXPECT_THAT(actual, IsProtoEqual(expected));
}

TEST(GrpcNotificationRequestParser, ListNotifications) {
  v2::ListNotificationsRequest expected;
  ASSERT_TRUE(google::protobuf::TextFormat::ParseFromString(
      R"pb(
        parent: "projects/_/buckets/test-bucket-name"
      )pb",
      &expected));

  storage::internal::ListNotificationsRequest req("test-bucket-name");

  auto const actual = ToProto(req);
  EXPECT_THAT(actual, IsProtoEqual(expected));
}

TEST(GrpcNotificationRequestParser, ListNotificationsResponse) {
  v2::ListNotificationsResponse input;
  ASSERT_TRUE(google::protobuf::TextFormat::ParseFromString(
      R"pb(
        notifications {
          name: "projects/_/buckets/test-bucket-name/notificationConfigs/test-id-1"
          etag: "test-etag-1"
          topic: "//pubsub.googleapis.com/projects/test-topic-project/topics/test-topic-id-1"
          event_types: "OBJECT_DELETE"
          event_types: "OBJECT_ARCHIVE"
          custom_attributes { key: "test-key-0" value: "test-value-0" }
          custom_attributes { key: "test-key-1" value: "test-value-1" }
          object_name_prefix: "test-object-name-prefix/"
          payload_format: "JSON_API_V1"
        }
        notifications {
          name: "projects/_/buckets/test-bucket-name/notificationConfigs/test-id-2"
          etag: "test-etag-2"
          topic: "//pubsub.googleapis.com/projects/test-topic-project/topics/test-topic-id-2"
          payload_format: "JSON_API_V1"
        }
      )pb",
      &input));

  auto const actual = FromProto(input);
  EXPECT_THAT(
      actual.items,
      ElementsAre(
          storage::NotificationMetadata("test-id-1", "test-etag-1")
              .set_topic("projects/test-topic-project/topics/test-topic-id-1")
              .append_event_type("OBJECT_DELETE")
              .append_event_type("OBJECT_ARCHIVE")
              .upsert_custom_attributes("test-key-0", "test-value-0")
              .upsert_custom_attributes("test-key-1", "test-value-1")
              .set_object_name_prefix("test-object-name-prefix/")
              .set_payload_format("JSON_API_V1"),
          storage::NotificationMetadata("test-id-2", "test-etag-2")
              .set_topic("projects/test-topic-project/topics/test-topic-id-2")
              .set_payload_format("JSON_API_V1")));
}

}  // namespace
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
}  // namespace storage_internal
}  // namespace cloud
}  // namespace google


text:
set current_dir=%CD%
cd %EXALGO_PARENT_FOLDER%\utility
automation_all.py -p "%current_dir%\..\halide_blur_hvscan_test.exe" -e halide_blur_hvscan_test -s extract -f a.png -i a.png -o out.png
:: -d -dl 4
cd %current_dir%