text:
package br.usp.icmc.amenu.generator;

import br.usp.icmc.amenu.aMenu.Config;
import br.usp.icmc.amenu.aMenu.Configurations;
import br.usp.icmc.amenu.aMenu.Direction;
import br.usp.icmc.amenu.aMenu.Icon;
import br.usp.icmc.amenu.aMenu.Item;
import br.usp.icmc.amenu.aMenu.Menu;
import br.usp.icmc.amenu.aMenu.Style;
import br.usp.icmc.amenu.aMenu.SubMenu;
import br.usp.icmc.amenu.aMenu.Target;
import br.usp.icmc.amenu.generator.ColorMenu;
import com.google.common.base.Objects;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.eclipse.emf.common.util.EList;
import org.eclipse.xtend2.lib.StringConcatenation;

@SuppressWarnings("all")
public abstract class MenuAbstract {
  private String _id_menu;

  private String _id_itens;

  protected Menu _menu;

  protected ColorMenu _color;

  private int _count_sub_menu;

  private int _count_item;

  public MenuAbstract(final Menu menu) {
    this._menu = menu;
    String _name = menu.getName();
    boolean _notEquals = (!Objects.equal(_name, null));
    if (_notEquals) {
      String _name_1 = menu.getName();
      this._id_menu = _name_1;
    } else {
      this._id_menu = "accessible-menu";
    }
    this._initColors();
    this._count_sub_menu = 0;
    this._count_item = 0;
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
    Date _date = new Date();
    String _format = dateFormat.format(_date);
    String _plus = ((this._id_menu + "-") + _format);
    this._id_itens = _plus;
  }

  public String getIdMenu() {
    return this._id_menu;
  }

  public String getIdItens() {
    return this._id_itens;
  }

  public Menu getMenu() {
    return this._menu;
  }

  public Style getStyle() {
    return this._menu.getStyle();
  }

  private void _initColors() {
    ColorMenu _colorMenu = new ColorMenu();
    this._color = _colorMenu;
    this._color.setTop("background", "#4cb6ea");
    this._color.setTop("background-hover", "#FFFFFF");
    this._color.setTop("color", "#FFFFFF");
    this._color.setTop("color-hover", "#000000");
    this._color.setTop("border", "#4cb6ea");
    this._color.setChildren("background", "#FFFFFF");
    this._color.setChildren("background-hover", "#FFFFFF");
    this._color.setChildren("color", "#000000");
    this._color.setChildren("color-hover", "#4cb6ea");
    this._color.setChildren("border", "#BBBBBB");
    Configurations _configuration = this._menu.getConfiguration();
    boolean _notEquals = (!Objects.equal(_configuration, null));
    if (_notEquals) {
      Configurations _configuration_1 = this._menu.getConfiguration();
      EList<Config> _config_top = _configuration_1.getConfig_top();
      for (final Config i : _config_top) {
        String _feature = i.getFeature();
        String _color = i.getColor();
        this._color.setTop(_feature, _color);
      }
      Configurations _configuration_2 = this._menu.getConfiguration();
      EList<Config> _config_children = _configuration_2.getConfig_children();
      for (final Config i_1 : _config_children) {
        String _feature_1 = i_1.getFeature();
        String _color_1 = i_1.getColor();
        this._color.setChildren(_feature_1, _color_1);
      }
    }
  }

  protected abstract CharSequence _colorSimple();

  protected abstract CharSequence _colorComplex();

  public final CharSequence genCss() {
    CharSequence _switchResult = null;
    Style _style = this._menu.getStyle();
    if (_style != null) {
      switch (_style) {
        case SIMPLE:
          _switchResult = this._colorSimple();
          break;
        case COMPLEX:
          _switchResult = this._colorComplex();
          break;
        default:
          _switchResult = this._colorSimple();
          break;
      }
    } else {
      _switchResult = this._colorSimple();
    }
    return _switchResult;
  }

  public abstract CharSequence genJavascript();

  public final CharSequence genHtml() {
    CharSequence _xblockexpression = null;
    {
      int num_id = 1;
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("");
      _builder.newLineIfNotEmpty();
      _builder.append("\t");
      _builder.append("
");
      _builder.newLine();
      {
        EList<Item> _items = this._menu.getItems();
        for(final Item i : _items) {
          _builder.append("\t\t");
          int _plusPlus = num_id++;
          CharSequence _genItem = this.genItem(i, "-", _plusPlus);
          _builder.append(_genItem, "\t\t");
          _builder.newLineIfNotEmpty();
        }
      }
      _builder.append("\t");
      _builder.append("
");
      _builder.newLine();
      _builder.append("");
      _builder.newLine();
      _xblockexpression = _builder;
    }
    return _xblockexpression;
  }

  private final CharSequence genSubMenu(final SubMenu m, final String num_parent) {
    CharSequence _xblockexpression = null;
    {
      int num_id = 1;
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("<ul id=\"");
      _builder.append(this._id_itens, "");
      _builder.append(num_parent, "");
      _builder.append("0\" aria-hidden=\"true\" role=\"menu\" class=\"sub-nav-group sub-nav");
      {
        String _decorator = m.getDecorator();
        boolean _notEquals = (!Objects.equal(_decorator, null));
        if (_notEquals) {
          _builder.append(" ");
          String _decorator_1 = m.getDecorator();
          _builder.append(_decorator_1, "");
        }
      }
      _builder.append("\" aria-labelledby=\"");
      _builder.append(this._id_itens, "");
      _builder.append(num_parent, "");
      _builder.append("\">");
      _builder.newLineIfNotEmpty();
      {
        EList<Item> _items = m.getItems();
        for(final Item i : _items) {
          _builder.append("\t");
          int _plusPlus = num_id++;
          CharSequence _genItem = this.genItem(i, num_parent, _plusPlus);
          _builder.append(_genItem, "\t");
          _builder.newLineIfNotEmpty();
        }
      }
      _builder.append("
");
      _builder.newLine();
      _xblockexpression = _builder;
    }
    return _xblockexpression;
  }

  private final CharSequence genItem(final Item item, final String num_parent, final int num_item) {
    CharSequence _xblockexpression = null;
    {
      int tabindex = (-1);
      String id_item = ((this._id_itens + num_parent) + Integer.valueOf(num_item));
      String target = "";
      String title = "";
      boolean _equals = num_parent.equals("-");
      if (_equals) {
        tabindex = 0;
      }
      Target _target = item.getTarget();
      boolean _notEquals = (!Objects.equal(_target, null));
      if (_notEquals) {
        Target _target_1 = item.getTarget();
        boolean _equals_1 = _target_1.equals(Target._BLANK);
        if (_equals_1) {
          title = " title=\"(Link aberto em uma nova janela)";
        }
        Target _target_2 = item.getTarget();
        String _plus = (" target=\"" + _target_2);
        String _plus_1 = (_plus + "\"");
        target = _plus_1;
      }
      String _title = item.getTitle();
      boolean _notEquals_1 = (!Objects.equal(_title, null));
      if (_notEquals_1) {
        boolean _equals_2 = title.equals("");
        if (_equals_2) {
          String _title_1 = item.getTitle();
          String _plus_2 = (" title=\"" + _title_1);
          String _plus_3 = (_plus_2 + "\"");
          title = _plus_3;
        } else {
          String _title_2 = title;
          String _title_3 = item.getTitle();
          String _plus_4 = (" " + _title_3);
          String _plus_5 = (_plus_4 + "\"");
          title = (_title_2 + _plus_5);
        }
      }
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("<li");
      {
        String _name = item.getName();
        boolean _notEquals_2 = (!Objects.equal(_name, null));
        if (_notEquals_2) {
          _builder.append(" id=\"");
          String _name_1 = item.getName();
          _builder.append(_name_1, "");
          _builder.append("\"");
        }
      }
      _builder.append(" role=\"menuitem\" class=\"nav-item");
      {
        SubMenu _submenu = item.getSubmenu();
        boolean _notEquals_3 = (!Objects.equal(_submenu, null));
        if (_notEquals_3) {
          _builder.append(" has-sub");
        }
      }
      _builder.append("\"");
      {
        boolean _equals_3 = num_parent.equals("-");
        boolean _not = (!_equals_3);
        if (_not) {
          _builder.append(" aria-describedby=\"");
          _builder.append(this._id_itens, "");
          int _length = num_parent.length();
          int _minus = (_length - 1);
          String _substring = num_parent.substring(0, _minus);
          _builder.append(_substring, "");
          _builder.append("\"");
        }
      }
      _builder.append(">");
      _builder.newLineIfNotEmpty();
      {
        String _action = item.getAction();
        boolean _notEquals_4 = (!Objects.equal(_action, null));
        if (_notEquals_4) {
          _builder.append("\t");
          _builder.append("<a id=\"");
          _builder.append(id_item, "\t");
          _builder.append("\" href=\"");
          String _action_1 = item.getAction();
          _builder.append(_action_1, "\t");
          _builder.append("\"");
          _builder.append(title, "\t");
          _builder.append(target, "\t");
          {
            Direction _direction = item.getDirection();
            boolean _notEquals_5 = (!Objects.equal(_direction, null));
            if (_notEquals_5) {
              _builder.append(" dir=\"");
              Direction _direction_1 = item.getDirection();
              _builder.append(_direction_1, "\t");
              _builder.append("\"");
            }
          }
          _builder.append(" tabindex=\"");
          _builder.append(tabindex, "\t");
          _builder.append("\"");
          {
            SubMenu _submenu_1 = item.getSubmenu();
            boolean _notEquals_6 = (!Objects.equal(_submenu_1, null));
            if (_notEquals_6) {
              _builder.append(" aria-haspopup=\"true\" aria-owns=\"");
              _builder.append(id_item, "\t");
              _builder.append("-0\" aria-controls=\"");
              _builder.append(id_item, "\t");
              _builder.append("-0\" aria-expanded=\"false\"");
            }
          }
          _builder.append(">");
          _builder.newLineIfNotEmpty();
          {
            Icon _icon = item.getIcon();
            boolean _notEquals_7 = (!Objects.equal(_icon, null));
            if (_notEquals_7) {
              _builder.append("\t\t");
              Icon _icon_1 = item.getIcon();
              CharSequence _genIcon = this.genIcon(_icon_1);
              _builder.append(_genIcon, "\t\t");
              _builder.newLineIfNotEmpty();
            }
          }
          String _label = item.getLabel();
          _builder.append(_label, "");
          _builder.newLineIfNotEmpty();
          _builder.append("\t");
          _builder.append("");
          _builder.newLine();
        } else {
          _builder.append("\t");
          _builder.append("<span id=\"");
          _builder.append(id_item, "\t");
          _builder.append("\" role=\"button\"");
          _builder.append(title, "\t");
          _builder.append(target, "\t");
          {
            Direction _direction_2 = item.getDirection();
            boolean _notEquals_8 = (!Objects.equal(_direction_2, null));
            if (_notEquals_8) {
              _builder.append(" dir=\"");
              Direction _direction_3 = item.getDirection();
              _builder.append(_direction_3, "\t");
              _builder.append("\"");
            }
          }
          _builder.append(" tabindex=\"");
          _builder.append(tabindex, "\t");
          _builder.append("\"");
          {
            SubMenu _submenu_2 = item.getSubmenu();
            boolean _notEquals_9 = (!Objects.equal(_submenu_2, null));
            if (_notEquals_9) {
              _builder.append(" aria-haspopup=\"true\" aria-owns=\"");
              _builder.append(id_item, "\t");
              _builder.append("-0\" aria-controls=\"");
              _builder.append(id_item, "\t");
              _builder.append("-0\" aria-expanded=\"false\"");
            }
          }
          _builder.append(">");
          _builder.newLineIfNotEmpty();
          {
            Icon _icon_2 = item.getIcon();
            boolean _notEquals_10 = (!Objects.equal(_icon_2, null));
            if (_notEquals_10) {
              _builder.append("\t\t");
              Icon _icon_3 = item.getIcon();
              CharSequence _genIcon_1 = this.genIcon(_icon_3);
              _builder.append(_genIcon_1, "\t\t");
              _builder.newLineIfNotEmpty();
            }
          }
          String _label_1 = item.getLabel();
          _builder.append(_label_1, "");
          _builder.newLineIfNotEmpty();
          _builder.append("\t");
          _builder.append("");
          _builder.newLine();
        }
      }
      {
        SubMenu _submenu_3 = item.getSubmenu();
        boolean _notEquals_11 = (!Objects.equal(_submenu_3, null));
        if (_notEquals_11) {
          _builder.append("\t");
          SubMenu _submenu_4 = item.getSubmenu();
          CharSequence _genSubMenu = this.genSubMenu(_submenu_4, ((num_parent + Integer.valueOf(num_item)) + "-"));
          _builder.append(_genSubMenu, "\t");
          _builder.newLineIfNotEmpty();
        }
      }
      _builder.append("
");
      _builder.newLine();
      _xblockexpression = _builder;
    }
    return _xblockexpression;
  }

  private final CharSequence genIcon(final Icon icon) {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("<img ");
    {
      String _name = icon.getName();
      boolean _notEquals = (!Objects.equal(_name, null));
      if (_notEquals) {
        _builder.append(" id=\"");
        String _name_1 = icon.getName();
        _builder.append(_name_1, "");
        _builder.append("\" ");
      }
    }
    _builder.append(" src=\"");
    String _address = icon.getAddress();
    _builder.append(_address, "");
    _builder.append(" alt=\"");
    String _text_alt = icon.getText_alt();
    _builder.append(_text_alt, "");
    _builder.append("\"");
    {
      String _decorator = icon.getDecorator();
      boolean _notEquals_1 = (!Objects.equal(_decorator, null));
      if (_notEquals_1) {
        _builder.append(" class=\"");
        String _decorator_1 = icon.getDecorator();
        _builder.append(_decorator_1, "");
        _builder.append("\"");
      }
    }
    _builder.append(" />");
    _builder.newLineIfNotEmpty();
    return _builder;
  }
}


text:
package org.directwebremoting.webwork;

import java.util.Map;

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

/**
 * DWRAction pre/post processor.
 *
 * @author Alexandru Popescu
 */
public interface IDWRActionProcessor
{
    /**
     *
     * @param request
     * @param originalResponse
     * @param actionResponse
     * @param invocationParameters
     */
    void preProcess(HttpServletRequest request, HttpServletResponse originalResponse, HttpServletResponse actionResponse, Map<String, String> invocationParameters);

    /**
     *
     * @param request
     * @param originalResponse
     * @param actionResponse
     * @param result
     */
    void postProcess(HttpServletRequest request, HttpServletResponse originalResponse, HttpServletResponse actionResponse, AjaxResult result);
}

redpajama_set_name: RedPajamaGithub


text:
import React from 'react';
import ReactMarkdown from 'react-markdown';
import './md.css';

const input = `
| Name | Type | Default | Description |
|:-----|:-----|:-----|:-----|
| component | string | 'div' |  String component used for slider root. Defaults to 'div'. |
| rootStyle | object | {} |  An object with any inline styles you want applied to the root element. |
| rootProps | object | {} |  An object with any props you want applied to the root element. |
| className | string |  |  CSS class name applied to the root element of the slider. |
| domain | array | \\[0, 100\\] |  Two element array of numbers providing the min and max values for the slider \\[min, max\\] e.g. \\[0, 100\\]. It does not matter if the slider is reversed on the screen, domain is always \\[min, max\\] with min < max. |
| values* | array |  |  An array of numbers. You can supply one for a value slider, two for a range slider or more to create n-handled sliders. The values should correspond to valid step values in the domain. The numbers will be forced into the domain if they are two small or large. |
| step | number | 0.1 |  The step value for the slider. |
| mode | number or func | 1 |  The interaction mode. Value of 1 will allow handles to cross each other. Value of 2 will keep the sliders from crossing and separated by a step. Value of 3 will make the handles pushable and keep them a step apart. ADVANCED: You can also supply a function that will be passed the current values and the incoming update. Your function should return what the state should be set as. |
| vertical | bool | false |  Set to true if the slider is displayed vertically to tell the slider to use the height to calculate positions. |
| reversed | bool | false |  Reverse the display of slider values. |
| onChange | function | () => {} |  Function triggered when the value of the slider has changed. This will recieve changes at the end of a slide as well as changes from clicks on rails and tracks. Receives values. |
| onUpdate | function | () => {} |  Function called with the values at each update (caution: high-volume updates when dragging). Receives values. |
| onSlideStart | function | () => {} |  Function triggered with ontouchstart or onmousedown on a handle. Receives values. |
| onSlideEnd | function | () => {} |  Function triggered on ontouchend or onmouseup on a handle. Receives values. |
| disabled | bool | false |  Ignore all mouse, touch and keyboard events. |
| flatten | bool | false |  Render slider children as siblings. This is primarily for SVG sliders. See the SVG example. |
| warnOnChanges | bool | false |  When true, the slider will warn if values are changed to fit domain and step values.  Defaults to false. |
| children | any |  |  Component children to render. |
`;

export const SliderDocs: React.FC = () => {
  return <ReactMarkdown className="markdown-body" source={input} />;
};


text:
goog.require('ol.Map');
goog.require('ol.RendererHint');
goog.require('ol.View2D');
goog.require('ol.layer.Tile');
goog.require('ol.layer.Vector');
goog.require('ol.parser.ogc.GML_v3');
goog.require('ol.source.MapQuestOpenAerial');
goog.require('ol.source.Vector');
goog.require('ol.style.Fill');
goog.require('ol.style.Stroke');
goog.require('ol.style.Style');

var raster = new ol.layer.Tile({
  source: new ol.source.MapQuestOpenAerial()
});

var vector = new ol.layer.Vector({
  source: new ol.source.Vector({
    parser: new ol.parser.ogc.GML_v3(),
    url: 'data/gml/topp-states-wfs.xml'
  }),
  style: new ol.style.Style({
    symbolizers: [
      new ol.style.Fill({
        color: '#ffffff',
        opacity: 0.25
      }),
      new ol.style.Stroke({
        color: '#6666ff'
      })
    ]
  })
});

var map = new ol.Map({
  layers: [raster, vector],
  renderer: ol.RendererHint.CANVAS,
  target: 'map',
  view: new ol.View2D({
    center: [-10997171, 4658434],
    zoom: 4
  })
});


text:
// natString.cc - Implementation of java.lang.String native methods.

#include <config.h>

#include <string.h>
#include <stdlib.h>

#include <gcj/cni.h>
#include <java/lang/Character.h>
#include <java/lang/CharSequence.h>
#include <java/lang/String.h>
#include <java/lang/IndexOutOfBoundsException.h>
#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <java/lang/StringIndexOutOfBoundsException.h>
#include <java/lang/NullPointerException.h>
#include <java/lang/StringBuffer.h>
#include <java/io/ByteArrayOutputStream.h>
#include <java/io/OutputStreamWriter.h>
#include <java/io/ByteArrayInputStream.h>
#include <java/io/InputStreamReader.h>
#include <java/util/Locale.h>
#include <gnu/gcj/convert/UnicodeToBytes.h>
#include <gnu/gcj/convert/BytesToUnicode.h>
#include <gnu/gcj/runtime/StringBuffer.h>
#include <jvm.h>

static jstring* strhash = NULL;
static int strhash_count = 0;  /* Number of slots used in strhash. */
static int strhash_size = 0;  /* Number of slots available in strhash.
                               * Assumed be power of 2! */

// Some defines used by toUpperCase / toLowerCase.
#define ESSET     0x00df
#define CAPITAL_S 0x0053
#define SMALL_I   0x0069
#define CAPITAL_I_WITH_DOT 0x0130
#define SMALL_DOTLESS_I    0x0131
#define CAPITAL_I 0x0049

#define DELETED_STRING ((jstring)(~0))
#define SET_STRING_IS_INTERNED(STR) /* nothing */

#define UNMASK_PTR(Ptr) (((unsigned long) (Ptr)) & ~0x01)
#define MASK_PTR(Ptr) (((unsigned long) (Ptr)) | 0x01)
#define PTR_MASKED(Ptr) (((unsigned long) (Ptr)) & 0x01)

/* Find a slot where the string with elements DATA, length LEN,
   and hash HASH should go in the strhash table of interned strings. */
jstring*
_Jv_StringFindSlot (jchar* data, jint len, jint hash)
{
  JvSynchronize sync (&java::lang::String::class$);

  int start_index = hash & (strhash_size - 1);
  int deleted_index = -1;

  int index = start_index;
  /* step must be non-zero, and relatively prime with strhash_size. */
  jint step = (hash ^ (hash >> 16)) | 1;
  do
    {
      jstring* ptr = &strhash[index];
      jstring value = (jstring) UNMASK_PTR (*ptr);
      if (value == NULL)
	{
	  if (deleted_index >= 0)
	    return (&strhash[deleted_index]);
	  else
	    return ptr;
	}
      else if (*ptr == DELETED_STRING)
	deleted_index = index;
      else if (value->length() == len
	       && memcmp(JvGetStringChars(value), data, 2*len) == 0)
	return (ptr);
      index = (index + step) & (strhash_size - 1);
    }
  while (index != start_index);
  // Note that we can have INDEX == START_INDEX if the table has no
  // NULL entries but does have DELETED_STRING entries.
  JvAssert (deleted_index >= 0);
  return &strhash[deleted_index];
}

/* Calculate a hash code for the string starting at PTR at given LENGTH.
   This uses the same formula as specified for java.lang.String.hash. */

static jint
hashChars (jchar* ptr, jint length)
{
  jchar* limit = ptr + length;
  jint hash = 0;
  // Updated specification from
  // http://www.javasoft.com/docs/books/jls/clarify.html.
  while (ptr < limit)
    hash = (31 * hash) + *ptr++;
  return hash;
}

jint
java::lang::String::hashCode()
{
  if (cachedHashCode == 0)
    cachedHashCode = hashChars(JvGetStringChars(this), length());
  return cachedHashCode;
}

jstring*
_Jv_StringGetSlot (jstring str)
{
  jchar* data = JvGetStringChars(str);
  int length = str->length();
  return _Jv_StringFindSlot(data, length, hashChars (data, length));
}

static void
rehash ()
{
  JvSynchronize sync (&java::lang::String::class$);

  if (strhash == NULL)
    {
      strhash_size = 1024;
      strhash = (jstring *) _Jv_AllocBytes (strhash_size * sizeof (jstring));
    }
  else
    {
      int i = strhash_size;
      jstring* ptr = strhash + i;
      int nsize = strhash_size * 2;
      jstring *next = (jstring *) _Jv_AllocBytes (nsize * sizeof (jstring));

      while (--i >= 0)
	{
	  --ptr;
	  if (*ptr == NULL || *ptr == DELETED_STRING)
	    continue;

	  /* This is faster equivalent of
	   * *__JvGetInternSlot(*ptr) = *ptr; */
	  jstring val = (jstring) UNMASK_PTR (*ptr);
	  jint hash = val->hashCode();
	  jint index = hash & (nsize - 1);
	  jint step = (hash ^ (hash >> 16)) | 1;
	  for (;;)
	    {
	      if (next[index] == NULL)
		{
		  next[index] = *ptr;
		  break;
		}
	      index = (index + step) & (nsize - 1);
	    }
	}

      strhash_size = nsize;
      strhash = next;
    }
}

jstring
java::lang::String::intern()
{
  JvSynchronize sync (&java::lang::String::class$);
  if (3 * strhash_count >= 2 * strhash_size)
    rehash();
  jstring* ptr = _Jv_StringGetSlot(this);
  if (*ptr != NULL && *ptr != DELETED_STRING)
    {
      // See description in _Jv_FinalizeString() to understand this.
      *ptr = (jstring) MASK_PTR (*ptr);
      return (jstring) UNMASK_PTR (*ptr);
    }
  jstring str = (this->data == this
		 ? this
		 : _Jv_NewString(JvGetStringChars(this), this->length()));
  SET_STRING_IS_INTERNED(str);
  strhash_count++;
  *ptr = str;
  // When string is GC'd, clear the slot in the hash table.
  _Jv_RegisterStringFinalizer (str);
  return str;
}

// The fake String finalizer.  This is only used when the String has
// been intern()d.  However, we must check this case, as it might be
// called by the Reference code for any String.
void
_Jv_FinalizeString (jobject obj)
{
  JvSynchronize sync (&java::lang::String::class$);

  // We might not actually have intern()d any strings at all, if
  // we're being called from Reference.
  if (! strhash)
    return;

  jstring str = reinterpret_cast<jstring> (obj);
  jstring *ptr = _Jv_StringGetSlot(str);
  if (*ptr == NULL || *ptr == DELETED_STRING
      || (jobject) UNMASK_PTR (*ptr) != obj)
    return;

  // We assume the lowest bit of the pointer is free for our nefarious
  // manipulations.  What we do is set it to `0' (implicitly) when
  // interning the String.  If we subsequently re-intern the same
  // String, then we set the bit.  When finalizing, if the bit is set
  // then we clear it and re-register the finalizer.  We know this is
  // a safe approach because both intern() and _Jv_FinalizeString()
  // acquire the class lock; this bit can't be manipulated when the
  // lock is not held.  So if we are finalizing and the bit is clear
  // then we know all references are gone and we can clear the entry
  // in the hash table.  The naive approach of simply clearing the
  // pointer here fails in the case where a request to intern a new
  // string with the same contents is made between the time the
  // intern()d string is found to be unreachable and when the
  // finalizer is actually run.  In this case we could clear a pointer
  // to a valid string, and future intern() calls for that particular
  // value would spuriously fail.
  if (PTR_MASKED (*ptr))
    {
      *ptr = (jstring) UNMASK_PTR (*ptr);
      _Jv_RegisterStringFinalizer (obj);
    }
  else
    {
      *ptr = DELETED_STRING;
      strhash_count--;
    }
}

jstring
_Jv_NewStringUTF (const char *bytes)
{
  int size = strlen (bytes);
  unsigned char *p = (unsigned char *) bytes;

  int length = _Jv_strLengthUtf8 ((char *) p, size);
  if (length < 0)
    return NULL;

  jstring jstr = JvAllocString (length);
  jchar *chrs = JvGetStringChars (jstr);

  p = (unsigned char *) bytes;
  unsigned char *limit = p + size;
  while (p < limit)
    *chrs++ = UTF8_GET (p, limit);

  return jstr;
}

jstring
_Jv_NewStringUtf8Const (Utf8Const* str)
{
  jchar *chrs;
  jchar buffer[100];
  jstring jstr;
  unsigned char* data = (unsigned char*) str->data;
  unsigned char* limit = data + str->length;
  int length = _Jv_strLengthUtf8(str->data, str->length);

  if (length <= (int) (sizeof(buffer) / sizeof(jchar)))
    {
      jstr = NULL;
      chrs = buffer;
    }
  else
    {
      jstr = JvAllocString(length);
      chrs = JvGetStringChars(jstr);
    }

  jint hash = 0;
  while (data < limit)
    {
      jchar ch = UTF8_GET(data, limit);
      hash = (31 * hash) + ch;
      *chrs++ = ch;
    }
  chrs -= length;

  JvSynchronize sync (&java::lang::String::class$);
  if (3 * strhash_count >= 2 * strhash_size)
    rehash();
  jstring* ptr = _Jv_StringFindSlot (chrs, length, hash);
  if (*ptr != NULL && *ptr != DELETED_STRING)
    return (jstring) UNMASK_PTR (*ptr);
  strhash_count++;
  if (jstr == NULL)
    {
      jstr = JvAllocString(length);
      chrs = JvGetStringChars(jstr);
      memcpy (chrs, buffer, sizeof(jchar)*length);
    }
  jstr->cachedHashCode = hash;
  *ptr = jstr;
  SET_STRING_IS_INTERNED(jstr);
  // When string is GC'd, clear the slot in the hash table.  Note that
  // we don't have to call _Jv_RegisterStringFinalizer here, as we
  // know the new object cannot be referred to by a Reference.
  _Jv_RegisterFinalizer ((void *) jstr, _Jv_FinalizeString);
  return jstr;
}

jsize
_Jv_GetStringUTFLength (jstring string)
{
  jsize len = 0;
  jchar *ptr = JvGetStringChars (string);
  jsize i = string->length();
  while (--i >= 0)
    {
      jchar ch = *ptr++;
      if (ch > 0 && ch <= 0x7F)
	len += 1;
      else if (ch <= 0x7FF)
	len += 2;
      else
	len += 3;
    }
  return len;
}

// Not sure this quite matches GetStringUTFRegion.
// null-termination of result?  len?  throw exception?
jsize
_Jv_GetStringUTFRegion (jstring str, jsize start, jsize len, char *buf)
{
  jchar *sptr = JvGetStringChars (str) + start;
  jsize i = len;
  char *dptr = buf;
  while (--i >= 0)
    {
      jchar ch = *sptr++;
      if (ch > 0 && ch <= 0x7F)
	*dptr++ = (char) ch;
      else if (ch <= 0x7FF)
	{
	  *dptr++ = (char) (0xC0 + ((ch >> 6) & 0x1F));
	  *dptr++ = (char) (0x80 + (ch & 0x3F));
	}
      else
	{
	  *dptr++ = (char) (0xE0 + ((ch >> 12) & 0xF));
	  *dptr++ = (char) (0x80 + ((ch >> 6) & 0x3F));
	  *dptr++ = (char) (0x80 + (ch & 0x3F));
	}
    }
  return dptr - buf;
}

/* Put printed (decimal) representation of NUM in a buffer.
   BUFEND marks the end of the buffer, which must be at least 11 jchars long.
   Returns the COUNT of jchars written.  The result is in
   (BUFEND - COUNT) (inclusive) upto (BUFEND) (exclusive). */

jint
_Jv_FormatInt (jchar* bufend, jint num)
{
  register jchar* ptr = bufend;
  jboolean isNeg;
  if (num < 0)
    {
      isNeg = true;
      if (num != (jint) -2147483648U)
	num = -(num);
      else
	{
	  // Handle special case of MIN_VALUE.
	  *--ptr = '8';
	  num = 214748364;
	}
      }
    else
      isNeg = false;

    do
      {
        *--ptr = (jchar) ((int) '0' + (num % 10));
        num /= 10;
      }
    while (num > 0);

    if (isNeg)
      *--ptr = '-';
    return bufend - ptr;
}

jstring
java::lang::String::valueOf (jint num)
{
  // Use an array large enough for "-2147483648"; i.e. 11 chars.
  jchar buffer[11];
  int i = _Jv_FormatInt (buffer+11, num);
  return _Jv_NewString (buffer+11-i, i);
}

jstring
_Jv_NewString(const jchar *chars, jsize len)
{
  jstring str = _Jv_AllocString(len);
  jchar* data = JvGetStringChars (str);
  memcpy (data, chars, len * sizeof (jchar));
  return str;
}

jstring
_Jv_NewStringLatin1(const char *bytes, jsize len)
{
  jstring str = JvAllocString(len);
  jchar* data = JvGetStringChars (str);
  while (--len >= 0)
    *data++ = *(unsigned char*)bytes++;
  return str;
}

void
java::lang::String::init(jcharArray chars, jint offset, jint count,
			 jboolean dont_copy)
{
  if (! chars)
    throw new NullPointerException;
  jsize data_size = JvGetArrayLength (chars);
  if (offset < 0 || count < 0 || offset + count < 0
      || offset + count > data_size)
    throw new ArrayIndexOutOfBoundsException;
  jcharArray array;
  jchar *pdst;
  if (! dont_copy)
    {
      array = JvNewCharArray(count);
      pdst = elements (array);
      memcpy (pdst, elements (chars) + offset, count * sizeof (jchar));
    }
  else
    {
      array = chars;
      pdst = &(elements(array)[offset]);
    }

  data = array;
  boffset = (char *) pdst - (char *) array;
  this->count = count;
}

void
java::lang::String::init(jbyteArray ascii, jint hibyte, jint offset,
			 jint count)
{
  if (! ascii)
    throw new NullPointerException;
  jsize data_size = JvGetArrayLength (ascii);
  if (offset < 0 || count < 0 || offset + count < 0
      || offset + count > data_size)
    throw new ArrayIndexOutOfBoundsException;
  jcharArray array = JvNewCharArray(count);
  jbyte *psrc = elements (ascii) + offset;
  jchar *pdst = elements (array);
  data = array;
  boffset = (char *) pdst - (char *) array;
  this->count = count;
  hibyte = (hibyte & 0xff) << 8;
  while (-- count >= 0)
    {
      *pdst++ = hibyte | (*psrc++ & 0xff);
    }
}

void
java::lang::String::init (jbyteArray bytes, jint offset, jint count,
			  jstring encoding)
{
  if (! bytes)
    throw new NullPointerException;
  jsize data_size = JvGetArrayLength (bytes);
  if (offset < 0 || count < 0 || offset + count < 0
      || offset + count > data_size)
    throw new ArrayIndexOutOfBoundsException;
  jcharArray array = JvNewCharArray (count);
  gnu::gcj::convert::BytesToUnicode *converter
    = gnu::gcj::convert::BytesToUnicode::getDecoder(encoding);
  jint outpos = 0;
  int avail = count;
  converter->setInput(bytes, offset, offset+count);
  while (converter->inpos < converter->inlength)
    {
      int done = converter->read(array, outpos, avail);
      if (done == 0)
	{
	  jint new_size = 2 * (outpos + avail);
	  jcharArray new_array = JvNewCharArray (new_size);
	  memcpy (elements (new_array), elements (array),
		  outpos * sizeof(jchar));
	  array = new_array;
	  avail = new_size - outpos;
	}
      else
	{
	  outpos += done;
	  avail -= done;
	}
    }
  converter->done ();
  this->data = array;
  this->boffset = (char *) elements (array) - (char *) array;
  this->count = outpos;
}

void
java::lang::String::init (gnu::gcj::runtime::StringBuffer *buffer)
{
  init (buffer->value, 0, buffer->count, true);
}

jboolean
java::lang::String::equals(jobject anObject)
{
  if (anObject == NULL)
    return false;
  if (anObject == this)
    return true;
  if (anObject->getClass() != &java::lang::String::class$)
    return false;
  jstring other = (jstring) anObject;
  if (count != other->count)
    return false;

  // If both have cached hash codes, check that.  If the cached hash
  // codes are zero, don't bother trying to compute them.
  int myHash = cachedHashCode;
  int otherHash = other->cachedHashCode;
  if (myHash && otherHash && myHash != otherHash)
    return false;

  // We could see if both are interned, and return false.  But that
  // seems too expensive.

  jchar *xptr = JvGetStringChars (this);
  jchar *yptr = JvGetStringChars (other);
  return ! memcmp (xptr, yptr, count * sizeof (jchar));
}

jboolean
java::lang::String::contentEquals(java::lang::StringBuffer* buffer)
{
  if (buffer == NULL)
    throw new NullPointerException;
  JvSynchronize sync(buffer);
  if (count != buffer->count)
    return false;
  if (data == buffer->value)
    return true; // Possible if shared.
  jchar *xptr = JvGetStringChars(this);
  jchar *yptr = elements(buffer->value);
  return ! memcmp (xptr, yptr, count * sizeof (jchar));
}

jboolean
java::lang::String::contentEquals(java::lang::CharSequence *seq)
{
  if (seq->length() != count)
    return false;
  jchar *value = JvGetStringChars(this);
  for (int i = 0; i < count; ++i)
    if (value[i] != seq->charAt(i))
      return false;
  return true;
}

jchar
java::lang::String::charAt(jint i)
{
  if (i < 0 || i >= count)
    throw new java::lang::StringIndexOutOfBoundsException(i);
  return JvGetStringChars(this)[i];
}

void
java::lang::String::getChars(jint srcBegin, jint srcEnd,
			     jcharArray dst, jint dstBegin)
{
  jint dst_length = JvGetArrayLength (dst);
  if (srcBegin < 0 || srcBegin > srcEnd || srcEnd > count)
    throw new java::lang::StringIndexOutOfBoundsException;
  // The 2nd part of the test below is equivalent to
  // dstBegin + (srcEnd-srcBegin) > dst_length
  // except that it does not overflow.
  if (dstBegin < 0 || dstBegin > dst_length - (srcEnd-srcBegin))
    throw new ArrayIndexOutOfBoundsException;
  jchar *dPtr = elements (dst) + dstBegin;
  jchar *sPtr = JvGetStringChars (this) + srcBegin;
  jint i = srcEnd - srcBegin;
  memcpy (dPtr, sPtr, i * sizeof (jchar));
}

jbyteArray
java::lang::String::getBytes (jstring enc)
{
  jint todo = length();
  jint buflen = todo;
  jbyteArray buffer = JvNewByteArray(todo);
  jint bufpos = 0;
  jint offset = 0;
  gnu::gcj::convert::UnicodeToBytes *converter
    = gnu::gcj::convert::UnicodeToBytes::getEncoder(enc);
  while (todo > 0 || converter->havePendingBytes())
    {
      converter->setOutput(buffer, bufpos);
      // We only really need to do a single write.
      converter->setFinished();
      int converted = converter->write(this, offset, todo, NULL);
      bufpos = converter->count;
      if (converted == 0 && bufpos == converter->count)
	{
	  buflen *= 2;
	  jbyteArray newbuffer = JvNewByteArray(buflen);
	  memcpy (elements (newbuffer), elements (buffer), bufpos);
	  buffer = newbuffer;
	}
      else
	bufpos = converter->count;

      offset += converted;
      todo -= converted;
    }
  converter->done ();
  if (bufpos == buflen)
    return buffer;
  jbyteArray result = JvNewByteArray(bufpos);
  memcpy (elements (result), elements (buffer), bufpos);
  return result;
}

void
java::lang::String::getBytes(jint srcBegin, jint srcEnd,
			     jbyteArray dst, jint dstBegin)
{
  jint dst_length = JvGetArrayLength (dst);
  if (srcBegin < 0 || srcBegin > srcEnd || srcEnd > count)
    throw new java::lang::StringIndexOutOfBoundsException;
  // The 2nd part of the test below is equivalent to
  // dstBegin + (srcEnd-srcBegin) > dst_length
  // except that it does not overflow.
  if (dstBegin < 0 || dstBegin > dst_length - (srcEnd-srcBegin))
    throw new ArrayIndexOutOfBoundsException;
  jbyte *dPtr = elements (dst) + dstBegin;
  jchar *sPtr = JvGetStringChars (this) + srcBegin;
  jint i = srcEnd-srcBegin;
  while (--i >= 0)
    *dPtr++ = (jbyte) *sPtr++;
}

jcharArray
java::lang::String::toCharArray()
{
  jcharArray array = JvNewCharArray(count);
  jchar *dPtr = elements (array);
  jchar *sPtr = JvGetStringChars (this);
  jint i = count;
  memcpy (dPtr, sPtr, i * sizeof (jchar));
  return array;
}

jboolean
java::lang::String::equalsIgnoreCase (jstring anotherString)
{
  if (anotherString == NULL || count != anotherString->count)
    return false;
  jchar *tptr = JvGetStringChars (this);
  jchar *optr = JvGetStringChars (anotherString);
  jint i = count;
  while (--i >= 0)
    {
      jchar tch = *tptr++;
      jchar och = *optr++;
      if (tch != och
	  && (java::lang::Character::toLowerCase (tch)
	      != java::lang::Character::toLowerCase (och))
	  && (java::lang::Character::toUpperCase (tch)
	      != java::lang::Character::toUpperCase (och)))
	return false;
    }
  return true;
}

jboolean
java::lang::String::regionMatches (jint toffset,
				   jstring other, jint ooffset, jint len)
{
  if (toffset < 0 || ooffset < 0 || len < 0
      || toffset > count - len
      || ooffset > other->count - len)
    return false;
  jchar *tptr = JvGetStringChars (this) + toffset;
  jchar *optr = JvGetStringChars (other) + ooffset;
  jint i = len;
  return ! memcmp (tptr, optr, i * sizeof (jchar));
}

jint
java::lang::String::compareTo (jstring anotherString)
{
  jchar *tptr = JvGetStringChars (this);
  jchar *optr = JvGetStringChars (anotherString);
  jint tlen = this->count;
  jint olen = anotherString->count;
  jint i = tlen > olen ? olen : tlen;
  while (--i >= 0)
    {
      jchar tch = *tptr++;
      jchar och = *optr++;
      if (tch != och)
	return (jint) tch - (jint) och;
    }
  return tlen - olen;
}

jboolean
java::lang::String::regionMatches (jboolean ignoreCase, jint toffset,
				   jstring other, jint ooffset, jint len)
{
  if (toffset < 0 || ooffset < 0 || len < 0
      || toffset > count - len
      || ooffset > other->count - len)
    return false;
  jchar *tptr = JvGetStringChars (this) + toffset;
  jchar *optr = JvGetStringChars (other) + ooffset;
  jint i = len;
  if (ignoreCase)
    {
      while (--i >= 0)
	{
	  jchar tch = *tptr++;
	  jchar och = *optr++;
	  if ((java::lang::Character::toLowerCase (tch)
	       != java::lang::Character::toLowerCase (och))
	      && (java::lang::Character::toUpperCase (tch)
		  != java::lang::Character::toUpperCase (och)))
	    return false;
	}
      return true;
    }
  return ! memcmp (tptr, optr, i * sizeof (jchar));
}

jboolean
java::lang::String::startsWith (jstring prefix, jint toffset)
{
  jint i = prefix->count;
  if (toffset < 0 || toffset > count - i)
    return false;
  jchar *xptr = JvGetStringChars (this) + toffset;
  jchar *yptr = JvGetStringChars (prefix);
  return ! memcmp (xptr, yptr, i * sizeof (jchar));
}

jint
java::lang::String::indexOf (jint ch, jint fromIndex)
{
  if (fromIndex < 0)
    fromIndex = 0;
  jchar *ptr = JvGetStringChars(this);
  for (;; ++fromIndex)
    {
      if (fromIndex >= count)
	return -1;
      if (ptr[fromIndex] == ch)
	return fromIndex;
    }
}

jint
java::lang::String::indexOf (jstring s, jint fromIndex)
{
  const jchar *const xchars = JvGetStringChars(s);
  const jchar *const ychars = JvGetStringChars(this) + fromIndex;

  const int xlength = s->length ();
  const int ylength = length () - fromIndex;

  int i = 0;
  int j = 0;

  while (i < ylength && j < xlength)
    {
      if (xchars[j] != ychars[i])
	{
	  i = i - j + 1;
	  j = 0;
	}
      else
	i++, j++;
    }

  if (j >= xlength)
    return fromIndex + i - xlength;
  else
    return -1;
}

jint
java::lang::String::lastIndexOf (jint ch, jint fromIndex)
{
  if (fromIndex >= count)
    fromIndex = count - 1;
  jchar *ptr = JvGetStringChars(this);
  for (;; --fromIndex)
    {
      if (fromIndex < 0)
	return -1;
      if (ptr[fromIndex] == ch)
	return fromIndex;
    }
}

jstring
java::lang::String::substring (jint beginIndex, jint endIndex)
{
  if (beginIndex < 0 || endIndex > count || beginIndex > endIndex)
    throw new StringIndexOutOfBoundsException;
  if (beginIndex == 0 && endIndex == count)
    return this;
  jint newCount = endIndex - beginIndex;
  // For very small strings, just allocate a new one.  For other
  // substrings, allocate a new one unless the substring is over half
  // of the original string.
  if (newCount <= 8 || newCount < (count >> 1))
    return JvNewString(JvGetStringChars(this) + beginIndex, newCount);
  jstring s = new String();
  s->data = data;
  s->count = newCount;
  s->boffset = boffset + sizeof(jchar) * beginIndex;
  return s;
}

jstring
java::lang::String::concat(jstring str)
{
  jint str_count = str->count;
  if (str_count == 0)
    return this;
  jstring result = JvAllocString(count + str_count);
  jchar *dstPtr = JvGetStringChars(result);
  jchar *srcPtr = JvGetStringChars(this);
  jint i = count;
  memcpy (dstPtr, srcPtr, i * sizeof (jchar));
  dstPtr += i;
  srcPtr = JvGetStringChars(str);
  i = str->count;
  memcpy (dstPtr, srcPtr, i * sizeof (jchar));
  return result;
}

jstring
java::lang::String::replace (jchar oldChar, jchar newChar)
{
  jint i;
  jchar* chrs = JvGetStringChars (this);
  for (i = 0;  ;  i++)
    {
      if (i == count)
	return this;
      if (chrs[i] == oldChar)
	break;
    }
  jstring result = JvAllocString (count);
  jchar *dPtr = JvGetStringChars (result);
  for (int j = 0;  j < i;  j++)
    *dPtr++ = chrs[j];
  for (; i < count;  i++)
    {
      jchar ch = chrs[i];
      if (ch == oldChar)
	ch = newChar;
      *dPtr++ = ch;
    }
  return result;
}

jstring
java::lang::String::toLowerCase (java::util::Locale *locale)
{
  jint i;
  jchar* chrs = JvGetStringChars(this);
  jchar ch = 0;

  bool handle_tr = false;
  if (locale != NULL)
    {
      String *lang = locale->getLanguage ();
      if (lang->length () == 2
	  && lang->charAt (0) == 't'
	  && lang->charAt (1) == 'r')
	handle_tr = true;
    }

  for (i = 0;  ;  i++)
    {
      if (i == count)
	return this;
      jchar origChar = chrs[i];

      if (handle_tr && (origChar == CAPITAL_I
			|| origChar == CAPITAL_I_WITH_DOT))
	break;

      ch = java::lang::Character::toLowerCase(origChar);
      if (ch != origChar)
	break;
    }
  jstring result = JvAllocString(count);
  jchar *dPtr = JvGetStringChars (result);
  for (int j = 0;  j < i;  j++)
    *dPtr++ = chrs[j];
  *dPtr++ = ch;  i++;
  for (; i < count;  i++)
    {
      if (handle_tr && chrs[i] == CAPITAL_I)
	*dPtr++ = SMALL_DOTLESS_I;
      else if (handle_tr && chrs[i] == CAPITAL_I_WITH_DOT)
	*dPtr++ = SMALL_I;
      else
	*dPtr++ = java::lang::Character::toLowerCase(chrs[i]);
    }
  return result;
}

jstring
java::lang::String::toUpperCase (java::util::Locale *locale)
{
  jint i;
  jchar* chrs = JvGetStringChars(this);
  jchar ch;

  // When handling a specific locale there might be special rules.
  // Currently all existing rules are simply handled inline, as there
  // are only two and they are documented in the online 1.2 docs.
  bool handle_esset = locale != NULL;
  bool handle_tr = false;
  if (locale != NULL)
    {
      String *lang = locale->getLanguage ();
      if (lang->length () == 2
	  && lang->charAt (0) == 't'
	  && lang->charAt (1) == 'r')
	handle_tr = true;
    }

  int new_count = count;
  bool new_string = false;
  for (i = 0;  ;  i++)
    {
      if (i == count)
	break;
      jchar origChar = chrs[i];

      if (handle_esset && origChar == ESSET)
	{
	  ++new_count;
	  new_string = true;
	}
      else if (handle_tr && (origChar == SMALL_I
			     || origChar == SMALL_DOTLESS_I))
	new_string = true;
      else
	{
	  ch = java::lang::Character::toUpperCase(origChar);
	  if (ch != origChar)
	    new_string = true;
	}

      if (new_string && ! handle_esset)
	break;
    }
  if (! new_string)
    return this;
  jstring result = JvAllocString(new_count);
  jchar *dPtr = JvGetStringChars (result);
  for (i = 0; i < count;  i++)
    {
      if (handle_esset && chrs[i] == ESSET)
	{
	  *dPtr++ = CAPITAL_S;
	  *dPtr++ = CAPITAL_S;
	}
      else if (handle_tr && chrs[i] == SMALL_I)
	*dPtr++ = CAPITAL_I_WITH_DOT;
      else if (handle_tr && chrs[i] == SMALL_DOTLESS_I)
	*dPtr++ = CAPITAL_I;
      else
	*dPtr++ = java::lang::Character::toUpperCase(chrs[i]);
    }
  return result;
}

jstring
java::lang::String::trim ()
{
  jchar* chrs = JvGetStringChars(this);
  if (count == 0 || (chrs[0] > ' ' && chrs[count-1] > ' '))
    return this;
  jint preTrim = 0;
  for (;; preTrim++)
    {
      if (preTrim == count)
	return new String();
      if (chrs[preTrim] > ' ')
	break;
    }
  jint endTrim = count;
  while (chrs[endTrim-1] <= ' ')
    endTrim--;
  return substring(preTrim, endTrim);
}

jstring
java::lang::String::valueOf(jcharArray data, jint offset, jint count)
{
  jint data_length = JvGetArrayLength (data);
  if (offset < 0 || count < 0 || offset > data_length - count)
    throw new ArrayIndexOutOfBoundsException;
  jstring result = JvAllocString(count);
  jchar *sPtr = elements (data) + offset;
  jchar *dPtr = JvGetStringChars(result);
  memcpy (dPtr, sPtr, count * sizeof (jchar));
  return result;
}

jstring
java::lang::String::valueOf(jchar c)
{
  jstring result = JvAllocString(1);
  JvGetStringChars (result)[0] = c;
  return result;
}


text:
namespace Skuld
{
	class UUID
	{
	private:
		uint32_t Data1;
		uint16_t Data2;
		uint16_t Data3;
		uint8_t Data4[8];
	public:
		UUID();
		UUID(const std::array<uint8_t, 16>& bytes);
		UUID(const uint8_t* bytes);
		UUID(uint64_t high, uint64_t low);

		static UUID Generate();
		static UUID FromString(StringView str);

		String ToString() const;

		uint64_t High() const;
		uint64_t Low() const;

		bool operator==(const UUID& b) const;
		bool operator!=(const UUID& b) const;
		bool operator>(const UUID& b) const;
		bool operator<(const UUID& b) const;
		bool operator>=(const UUID& b) const;
		bool operator<=(const UUID& b) const;
	};

	std::ostream& operator<<(std::ostream& out, const UUID& b);

	static_assert(sizeof(UUID) == 16, "sizeof(UUID) != 16");
}


text:
package com.v5ent.game.screens;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.assets.AssetManager;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.input.GestureDetector;
import com.v5ent.game.SomeWars;
import com.v5ent.game.core.Assets;
import com.v5ent.game.core.WorldController;
import com.v5ent.game.core.WorldRenderer;

public class MainGameScreen  implements Screen{
	SomeWars game; // Note it's "MyGame" not "Game"
	private WorldController worldController;
	private WorldRenderer worldRenderer;

	private boolean paused;

	public MainGameScreen(SomeWars someWars) {
		game = someWars;
	}

	@Override
	public void show () {
		// Initialize controller and renderer
		worldController = new WorldController(game);
		GestureDetector gestureDetector = new GestureDetector(10, 0.5f, 2, 0.15f, worldController);
		Gdx.input.setInputProcessor(gestureDetector);
		worldRenderer = new WorldRenderer(worldController);
	}

	@Override
	public void render (float delta) {
		// Do not update game world when paused.
		if (!paused) {
			// Update game world by the time that has passed
			// since last rendered frame.
			worldController.update(delta);
		}
		// Sets the clear screen color to: Cornflower Blue
		Gdx.gl.glClearColor(0x64 / 255.0f, 0x95 / 255.0f, 0xed / 255.0f, 0xff / 255.0f);
		// Clears the screen
		Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
		// Render game world to screen
		worldRenderer.render();
	}

	@Override
	public void resize (int width, int height) {
		worldRenderer.resize(width, height);
	}

	@Override
	public void pause () {
		paused = true;
	}

	@Override
	public void resume () {
		Assets.instance.init(new AssetManager());
		paused = false;
	}

	@Override
	public void dispose () {
		if(worldRenderer!=null){
			worldRenderer.dispose();
		}
	}

	@Override
	public void hide() {
		// TODO Auto-generated method stub

	}
}


text:
int main()
{
    typedef std::chrono::system_clock Clock;
    typedef std::chrono::milliseconds Duration;
    std::chrono::time_point<Clock, Duration> t = Duration(3);
}


text: exec $LOGTALKHOME/integration/qplgt.sh


text:
const path       = require('path')
const pkg        = require(path.join(process.cwd(), 'package.json'))
const {execSync} = require('child_process')

console.log(`> linking all peer dependencies of ${pkg.name} as children to be prebuilt into binary...`)

Object.keys(pkg.peerDependencies).map(dep => {
    if (dep.indexOf('nexrender') !== -1) {
        const command = `npm link --no-package-lock --legacy-peer-deps ../${dep.replace('@nexrender/', 'nexrender-')}`
        console.log(`executing > ${command}`)
        execSync(command)
    }
})


text:
#ifndef ALIESDTRACKCUTSWRAPPER_H
#define ALIESDTRACKCUTSWRAPPER_H

#include "AliVCuts.h"

class AliESDtrackCuts;

namespace PWG {

namespace EMCAL {

/**
 * @class AliEmcalESDTrackCutsWrapper
 * @brief Wrapper class around AliESDtrackCuts object with focus on AOD analysis
 * @ingroup EMCALCOREFW
 * @author Markus Fasel <markus.fasel@cern.ch>, Oak Ridge National Laboratory
 * @since Dec 6, 2017
 *
 * The function IsSelected is not properly implemented for AliAODTracks in AliESDtrackCuts,
 * though a minimal functionality is provided. Instead AliESDtrackCuts offer the functions
 * AcceptTrack for AliESDtracks, automatically used in IsSelected of AliESDtrackCuts, and
 * AcceptVTrack for other track objects inheriting from AliVTrack. The class delegates the
 * IsSelect function to the proper Select function for the input data type. The focus is
 * on virtual track selection frameworks which abstractize the track selection in order to
 * be blind to the input data type.
 */
class AliEmcalESDtrackCutsWrapper : public AliVCuts {
public:

  /**
   * @brief Dummy constructor
   */
  AliEmcalESDtrackCutsWrapper();

  /**
   * @brief Main constructor
   *
   * @param name Name of the track cuts
   * @param trackcuts Underlying track cuts object
   */
  AliEmcalESDtrackCutsWrapper(const char *name, AliESDtrackCuts *trackcuts = NULL);

  /**
   * @brief Destructor
   */
  virtual ~AliEmcalESDtrackCutsWrapper();

  void SetESDTrackCuts(AliESDtrackCuts *trackcuts) { fTrackCuts = trackcuts; }
  AliESDtrackCuts *GetTrackCuts() const { return fTrackCuts; }

  /**
   * @brief Checking whether track is accepted by the underlying AliESDtrackCuts
   *
   * @param o Object to be checked
   * @return true Track is accepted by the track cuts
   * @return false Track is rejected by the track cuts or input type is unsupported
   */
  virtual bool IsSelected(TObject *o);

private:

  AliESDtrackCuts         *fTrackCuts;      ///< Underlying track cuts object

  AliEmcalESDtrackCutsWrapper(AliEmcalESDtrackCutsWrapper &);
  AliEmcalESDtrackCutsWrapper &operator=(const AliEmcalESDtrackCutsWrapper &);

  /// \cond CLASSIMP
  ClassDef(AliEmcalESDtrackCutsWrapper, 1);
  /// \endcond
};

}

}
#endif


text:
import * as React from 'react';

declare module 'primereact/avatar' {

    type SizeType = 'normal' | 'large' | 'xlarge';

    type ShapeType = 'square' | 'circle';

    type TemplateType = React.ReactNode | ((props: AvatarProps) => React.ReactNode);

    export interface AvatarProps {
        label?: string;
        icon?: string;
        image?: string;
        size?: SizeType;
        shape?: ShapeType;
        style?: object;
        className?: string;
        template?: TemplateType;
        imageAlt?: string;
        onImageError?(event: React.SyntheticEvent): void;
        onClick?(event: React.MouseEvent<HTMLElement>): void;
    }

    export class Avatar extends React.Component<AvatarProps, any> { }
}


text:
describe('CanvasKit\'s Path Behavior', function() {
    let container = document.createElement('div');
    document.body.appendChild(container);
    const CANVAS_WIDTH = 600;
    const CANVAS_HEIGHT = 600;

    beforeEach(function() {
        container.innerHTML = `
            <canvas width=600 height=600 id=test></canvas>
            <canvas width=600 height=600 id=report></canvas>`;
    });

    afterEach(function() {
        container.innerHTML = '';
    });

    it('can draw a path', function(done) {
        LoadCanvasKit.then(catchException(done, () => {
            // This is taken from example.html
            const surface = CanvasKit.MakeCanvasSurface('test');
            expect(surface).toBeTruthy('Could not make surface')
            if (!surface) {
                done();
                return;
            }
            const canvas = surface.getCanvas();
            const paint = new CanvasKit.SkPaint();
            paint.setStrokeWidth(1.0);
            paint.setAntiAlias(true);
            paint.setColor(CanvasKit.Color(0, 0, 0, 1.0));
            paint.setStyle(CanvasKit.PaintStyle.Stroke);

            const path = new CanvasKit.SkPath();
            path.moveTo(20, 5);
            path.lineTo(30, 20);
            path.lineTo(40, 10);
            path.lineTo(50, 20);
            path.lineTo(60, 0);
            path.lineTo(20, 5);

            path.moveTo(20, 80);
            path.cubicTo(90, 10, 160, 150, 190, 10);

            path.moveTo(36, 148);
            path.quadTo(66, 188, 120, 136);
            path.lineTo(36, 148);

            path.moveTo(150, 180);
            path.arcTo(150, 100, 50, 200, 20);
            path.lineTo(160, 160);

            path.moveTo(20, 120);
            path.lineTo(20, 120);

            path.transform([2, 0, 0,
                            0, 2, 0,
                            0, 0, 1 ])

            canvas.drawPath(path, paint);

            let rrect = new CanvasKit.SkPath()
                               .addRoundRect(100, 10, 140, 62,
                                             10, 4, true);

            canvas.drawPath(rrect, paint);
            rrect.delete();

            surface.flush();

            path.delete();
            paint.delete();

            reportSurface(surface, 'path_api_example', done);
        }));
        // See PathKit for more tests, since they share implementation
    });

    it('can draw directly to a canvas', function(done) {
        LoadCanvasKit.then(catchException(done, () => {
            // This is taken from example.html
            const surface = CanvasKit.MakeCanvasSurface('test');
            expect(surface).toBeTruthy('Could not make surface')
            if (!surface) {
                done();
                return;
            }
            const canvas = surface.getCanvas();
            const paint = new CanvasKit.SkPaint();
            paint.setStrokeWidth(2.0);
            paint.setAntiAlias(true);
            paint.setColor(CanvasKit.Color(0, 0, 0, 1.0));
            paint.setStyle(CanvasKit.PaintStyle.Stroke);

            canvas.drawLine(3, 10, 30, 15, paint);
            canvas.drawRoundRect(CanvasKit.LTRBRect(5, 35, 45, 80), 15, 10, paint);

            canvas.drawOval(CanvasKit.LTRBRect(5, 35, 45, 80), paint);

            canvas.drawArc(CanvasKit.LTRBRect(55, 35, 95, 80), 15, 270, true, paint);

            const font = new CanvasKit.SkFont(null, 20);
            canvas.drawText('this is ascii text', 5, 100, paint, font);

            const blob = CanvasKit.SkTextBlob.MakeFromText('Unicode chars 💩 é É ص', font);
            canvas.drawTextBlob(blob, 5, 130, paint);

            surface.flush();
            font.delete();
            blob.delete();
            paint.delete();

            reportSurface(surface, 'canvas_api_example', done);
        }));
        // See canvas2d for more API tests
    });

    function starPath(CanvasKit, X=128, Y=128, R=116) {
        let p = new CanvasKit.SkPath();
        p.moveTo(X + R, Y);
        for (let i = 1; i < 8; i++) {
          let a = 2.6927937 * i;
          p.lineTo(X + R * Math.cos(a), Y + R * Math.sin(a));
        }
        return p;
      }

    it('can apply an effect and draw text', function(done) {
        LoadCanvasKit.then(catchException(done, () => {
            const surface = CanvasKit.MakeCanvasSurface('test');
            expect(surface).toBeTruthy('Could not make surface')
            if (!surface) {
                done();
                return;
            }
            const canvas = surface.getCanvas();
            const path = starPath(CanvasKit);

            const paint = new CanvasKit.SkPaint();

            const textPaint = new CanvasKit.SkPaint();
            textPaint.setColor(CanvasKit.Color(40, 0, 0, 1.0));
            textPaint.setAntiAlias(true);

            const textFont = new CanvasKit.SkFont(null, 30);

            const dpe = CanvasKit.MakeSkDashPathEffect([15, 5, 5, 10], 1);

            paint.setPathEffect(dpe);
            paint.setStyle(CanvasKit.PaintStyle.Stroke);
            paint.setStrokeWidth(5.0);
            paint.setAntiAlias(true);
            paint.setColor(CanvasKit.Color(66, 129, 164, 1.0));

            canvas.clear(CanvasKit.Color(255, 255, 255, 1.0));

            canvas.drawPath(path, paint);
            canvas.drawText('This is text', 10, 280, textPaint, textFont);
            surface.flush();
            dpe.delete();
            path.delete();

            reportSurface(surface, 'effect_and_text_example', done);
        }));
    });

    it('can create a path from an SVG string', function(done) {
        LoadCanvasKit.then(catchException(done, () => {
            //.This is a parallelagram from
            // https://upload.wikimedia.org/wikipedia/commons/e/e7/Simple_parallelogram.svg
            let path = CanvasKit.MakePathFromSVGString('M 205,5 L 795,5 L 595,295 L 5,295 L 205,5 z');

            let cmds = path.toCmds();
            expect(cmds).toBeTruthy();
            // 1 move, 4 lines, 1 close
            // each element in cmds is an array, with index 0 being the verb, and the rest being args
            expect(cmds.length).toBe(6);
            expect(cmds).toEqual([[CanvasKit.MOVE_VERB, 205, 5],
                                  [CanvasKit.LINE_VERB, 795, 5],
                                  [CanvasKit.LINE_VERB, 595, 295],
                                  [CanvasKit.LINE_VERB, 5, 295],
                                  [CanvasKit.LINE_VERB, 205, 5],
                                  [CanvasKit.CLOSE_VERB]]);
            path.delete();
            done();
        }));
    });

     it('can create an SVG string from a path', function(done) {
        LoadCanvasKit.then(catchException(done, () => {
            let cmds = [[CanvasKit.MOVE_VERB, 205, 5],
                       [CanvasKit.LINE_VERB, 795, 5],
                       [CanvasKit.LINE_VERB, 595, 295],
                       [CanvasKit.LINE_VERB, 5, 295],
                       [CanvasKit.LINE_VERB, 205, 5],
                       [CanvasKit.CLOSE_VERB]];
            let path = CanvasKit.MakePathFromCmds(cmds);

            let svgStr = path.toSVGString();
            // We output it in terse form, which is different than Wikipedia's version
            expect(svgStr).toEqual('M205 5L795 5L595 295L5 295L205 5Z');
            path.delete();
            done();
        }));
    });
});


text:
package org.mdbda.diagrameditor.features.resources;

import org.eclipse.graphiti.datatypes.IDimension;
import org.eclipse.graphiti.features.IAddFeature;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.IAddContext;
import org.eclipse.graphiti.mm.algorithms.Polygon;
import org.eclipse.graphiti.mm.algorithms.Rectangle;
import org.eclipse.graphiti.mm.algorithms.RoundedRectangle;
import org.eclipse.graphiti.mm.algorithms.Text;
import org.eclipse.graphiti.mm.algorithms.styles.Color;
import org.eclipse.graphiti.mm.algorithms.styles.Orientation;
import org.eclipse.graphiti.mm.pictograms.BoxRelativeAnchor;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.PictogramElement;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.services.IGaService;
import org.eclipse.graphiti.services.IPeCreateService;
import org.eclipse.graphiti.util.ColorConstant;
import org.eclipse.graphiti.util.IColorConstant;
import org.mdbda.model.MDBDAModelRoot;
import org.mdbda.model.Resource;
import org.mdbda.model.Workflow;
import org.mdbda.diagrameditor.features.AbstactIOMDBDAAddFeature;
import org.mdbda.diagrameditor.pictogramelements.AbstractMDBDAShape;
import org.mdbda.diagrameditor.utils.AbstractSimpleMDBDAShapeHelper;
import org.mdbda.diagrameditor.utils.DataDescriptionShapeHelper;
import org.mdbda.diagrameditor.utils.LiveStatusShapeHelper;
import org.mdbda.diagrameditor.utils.NameShapeHelper;
import org.mdbda.diagrameditor.utils.SampleDataShapeHelper;
import org.mdbda.diagrameditor.utils.TestStatusShapeHelper;
import org.mdbda.diagrameditor.utils.TypeIdShapeHelper;

public abstract class AddResourceFeature extends AbstactIOMDBDAAddFeature
		implements IAddFeature {

	public AddResourceFeature(IFeatureProvider fp) {
		super(fp);
	}

	@Override
	public boolean canAdd(IAddContext context) {
		if (context.getNewObject() instanceof Resource) {
			if (getBusinessObjectForPictogramElement(context
					.getTargetContainer()) instanceof Workflow) {
				return true;
			}

			if (getBusinessObjectForPictogramElement(context
					.getTargetContainer()) instanceof MDBDAModelRoot) {
				return true;
			}
		}

		return false;
	}
	protected ColorConstant getBackgroundColor(){
	//	return  manageColor(new ColorConstant(127, 254, 165));//7FFEA5 (IColorConstant.LIGHT_BLUE);
		return new ColorConstant("99FFB7");//  manageColor(new ColorConstant(153, 255, 183));//99FFB7
	}

	@Override
	protected ColorConstant getForegroundColor() {
		return new ColorConstant("00661E");// manageColor(new ColorConstant(0,102,30));//(IColorConstant.BLUE);
	}
	@Override
	public PictogramElement add(IAddContext context) {

		ContainerShape targetShape = context.getTargetContainer();
		Resource resource = (Resource) context.getNewObject();

		int width = 100;
		int height = 80;

		IPeCreateService peCreateService = Graphiti.getPeCreateService();
		IGaService gaService = Graphiti.getGaService();

		ContainerShape rootContainerShapeForResourceElement = peCreateService
				.createContainerShape(targetShape, true);
		RoundedRectangle roundedRectangle;

		{
			Rectangle invisibleRectangle = gaService
					.createInvisibleRectangle(rootContainerShapeForResourceElement);
			gaService.setLocationAndSize(invisibleRectangle, context.getX(),
					context.getY(), width + 2
							* AbstractMDBDAShape.INVISIBLE_RECT_SIDE, height);

			roundedRectangle = gaService.createRoundedRectangle(
					invisibleRectangle, AbstractMDBDAShape.INVISIBLE_RECT_SIDE,
					AbstractMDBDAShape.INVISIBLE_RECT_SIDE);
			roundedRectangle
					.setBackground(manageColor(getBackgroundColor()));
			roundedRectangle
					.setForeground(manageColor(getForegroundColor()));
			roundedRectangle.setTransparency(0.2);
			roundedRectangle.setLineWidth(2);

			Graphiti.getPeService().setPropertyValue(roundedRectangle, AbstractSimpleMDBDAShapeHelper.SHAPE_KEY , ROUNDED_RECTANGLE_ID);
			gaService.setLocationAndSize(roundedRectangle,
					AbstractMDBDAShape.INVISIBLE_RECT_SIDE, 0, width, height);

			// if added Class has no resource we add it to the resource
			// of the diagram
			// in a real scenario the business model would have its own resource
			if (resource.eResource() == null) {
				getDiagram().eResource().getContents().add(resource);
			}
		}
		// create link and wire it
		link(rootContainerShapeForResourceElement, resource);

//		int typeTextHeight = addTypeIdText(resource, width, height,
//				rootContainerShapeForResourceElement, 5).getHeight();
//		addNameText(resource, width, height,
	//			rootContainerShapeForResourceElement, typeTextHeight);
		IFeatureProvider fp =  getFeatureProvider();
		IDimension status = new TestStatusShapeHelper(resource, rootContainerShapeForResourceElement, fp).addNewShapeOnContainer(width, height);
		new LiveStatusShapeHelper(resource, rootContainerShapeForResourceElement, fp).addNewShapeOnContainer(width, height);

		IDimension typeIdDim = new TypeIdShapeHelper(resource, rootContainerShapeForResourceElement,fp).addNewShapeOnContainer(width, height, 0, status.getHeight());
		new NameShapeHelper(resource, rootContainerShapeForResourceElement,fp).addNewShapeOnContainer(width, height, 0, typeIdDim.getHeight()+status.getHeight());

		new SampleDataShapeHelper(resource, rootContainerShapeForResourceElement, fp).addNewShapeOnContainer(width, height);
		new DataDescriptionShapeHelper(resource, rootContainerShapeForResourceElement, fp).addNewShapeOnContainer(width, height);

		// Anchor

		addOutputAnchor(resource, rootContainerShapeForResourceElement,
				0.5, getDiagram(), getFeatureProvider());

		addInputAnchor(resource, rootContainerShapeForResourceElement,
				0.5, getDiagram(), getFeatureProvider());

		layoutPictogramElement(rootContainerShapeForResourceElement);
		return rootContainerShapeForResourceElement;
	}
}


text:
package org.apache.fop.render.pdf;

import java.awt.geom.Rectangle2D;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;

import org.junit.Test;

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;

import org.apache.fop.pdf.PDFArray;
import org.apache.fop.pdf.PDFDictionary;
import org.apache.fop.pdf.PDFDocument;
import org.apache.fop.pdf.PDFName;
import org.apache.fop.pdf.PDFNumber;
import org.apache.fop.pdf.PDFObject;
import org.apache.fop.pdf.PDFPage;
import org.apache.fop.pdf.PDFResources;
import org.apache.fop.pdf.PDFStructElem;
import org.apache.fop.render.pdf.pdfbox.PDFBoxAdapter;
import org.apache.fop.render.pdf.pdfbox.TaggedPDFConductor;

import junit.framework.Assert;

public class TaggedPDFConductorTestCase {
    private static final String LINK = "/linkTagged.pdf";
    private static final String HELLO = "/helloWorld.pdf";
    private static final String TABLE = "/emptyRowTable.pdf";
    private static final String OTF = "/otf.pdf";
    private static final String IMAGE = "/hello2.pdf";
    private static final String NOPARENTTREE = "/NoParentTree.pdf";
    private PDFPage pdfPage;
    private PDFDocument pdfDoc;

    @Test
    public void testHandleLogicalStructure() throws IOException {
        PDFStructElem elem = new PDFStructElem();
        runConductor(LINK, elem);
        checkStructure(elem, 0);

        elem = new PDFStructElem();
        runConductor(HELLO, elem);
        PDFNumber mcid = (PDFNumber)elem.getKids().get(0);
        int test = mcid.getNumber().intValue();
        Assert.assertEquals(test, 0);

        elem = new PDFStructElem();
        runConductor(TABLE, elem);
        Assert.assertEquals(print(elem), "/Div/Part/Sect/Table/TBody/TR/TD/P/TD/P/TR/TD/TD");

        elem = new PDFStructElem();
        elem.put("Alt", "alt-text");
        runConductor(OTF, elem);
        Assert.assertEquals(print(elem), "/Div/Part/Art/P/Span");
        Assert.assertNull(elem.get("Alt"));
    }

    private String print(PDFStructElem x) throws IOException {
        StringBuilder sb = new StringBuilder(x.get("S").toString());
        if (x.getKids() != null) {
            for (PDFObject k : x.getKids()) {
                if (k instanceof PDFStructElem) {
                    sb.append(print((PDFStructElem) k));
                }
            }
            return sb.toString();
        }
        return "";
    }

    private void runConductor(String pdf, PDFStructElem elem) throws IOException {
        setUp();
        PDDocument doc = PDDocument.load(new File(getClass().getResource(pdf).getFile()));
        PDPage srcPage = doc.getPage(0);
        elem.setObjectNumber(2);
        PDFBoxAdapter adapter = new PDFBoxAdapter(
                pdfPage, new HashMap(),  new HashMap<Integer, PDFArray>());
        PDFLogicalStructureHandler handler = setUpPDFLogicalStructureHandler();
        new TaggedPDFConductor(elem, handler, srcPage, adapter).handleLogicalStructure(doc);
    }

    private void setUp() {
        Rectangle2D r = new Rectangle2D.Double();
        pdfPage = new PDFPage(new PDFResources(pdfDoc), 0, r, r, r, r);
        pdfDoc = new PDFDocument(" ");
        pdfDoc.makeStructTreeRoot(null);
        pdfPage.setObjectNumber(1);
        pdfPage.setDocument(pdfDoc);
    }

    private PDFLogicalStructureHandler setUpPDFLogicalStructureHandler() {
        PDFLogicalStructureHandler handler = new PDFLogicalStructureHandler(pdfDoc);
        handler.getParentTree().setDocument(pdfDoc);
        handler.startPage(pdfPage);
        return handler;
    }

    private void checkStructure(PDFStructElem elem, int index) {
        String [] types = {"Part", "Sect", "P"};
        List<PDFObject> list = elem.getKids();
        if (index != 3) {
            PDFStructElem kid = (PDFStructElem)list.get(0);
            String test = ((PDFName)kid.get("S")).getName();
            String expected = types[index];
            Assert.assertEquals(test, expected);
            index++;
            checkStructure(kid, index);
        } else {
            PDFDictionary firstKid = (PDFDictionary) list.get(0);
            int test = ((PDFNumber)firstKid.get("MCID")).getNumber().intValue();
            int expected = 0;
            Assert.assertEquals(test, expected);
            PDFDictionary firstKidSibling = (PDFDictionary) list.get(2);
            test = ((PDFNumber)firstKidSibling.get("MCID")).getNumber().intValue();
            expected = 2;
            Assert.assertEquals(test, expected);
            PDFStructElem second = (PDFStructElem)list.get(1);
            List secondKids = second.getKids();
            PDFStructElem secKid = (PDFStructElem) secondKids.get(0);
            List secondKidKids = secKid.getKids();
            PDFDictionary leafElem = (PDFDictionary)secondKidKids.get(0);
            test = ((PDFNumber)leafElem.get("MCID")).getNumber().intValue();
            expected = 1;
            Assert.assertEquals(test, expected);
        }
    }

    @Test
    public void testTaggedImagePDF() throws IOException {
        PDFStructElem elem = new PDFStructElem();
        runConductor(IMAGE, elem);
        Assert.assertEquals(print(elem), "/Div/Part/Sect/P/Image");
    }

    @Test
    public void testCreateDirectDescendants() throws IOException {
        PDFStructElem elem = new PDFStructElem();
        runConductor(NOPARENTTREE, elem);
        Assert.assertEquals(print(elem), "/Div/Document");
    }
}


text:
@interface PSStarView : PSView {
  CGFloat _rating;
}

@property (nonatomic, assign) CGFloat rating;

- (id)initWithFrame:(CGRect)frame rating:(CGFloat)rating;

@end


text:
ACCEPTED

#### According to
International Plant Names Index

#### Published in
null

#### Original name
Acacia merinthophora E.Pritz.

### Remarks
null


text:
package vg.civcraft.mc.namelayer.misc;

import vg.civcraft.mc.mercury.MercuryAPI;

public class Mercury {

	/**
	 * Invalidates a group across all servers.
	 * @param message- The message to send.
	 */
	public static void invalidateGroup(String message){
		MercuryAPI.instance.sendMessage("all", message, "namelayer");
	}
}


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

    <ImageView
        android:id="@+id/imageView2"
        android:layout_width="0dp"
        android:layout_height="150dp"
        android:layout_marginBottom="8dp"
        android:contentDescription="@string/sunny"
        android:scaleType="centerCrop"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintHorizontal_bias="0.0"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.0"
        app:srcCompat="@drawable/sunny" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="16dp"
        android:layout_marginLeft="16dp"
        android:text="Button"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        android:layout_marginStart="16dp" />

    <Button
        android:id="@+id/button2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="16dp"
        android:layout_marginRight="16dp"
        android:text="Button"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        android:layout_marginEnd="16dp" />

    <ListView
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:layout_marginBottom="0dp"
        android:layout_marginEnd="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="8dp"
        android:layout_marginStart="16dp"
        android:layout_marginTop="8dp"
        android:entries="@string/City"
        android:scrollbars="horizontal|vertical"
        app:layout_constraintBottom_toTopOf="@+id/button"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/imageView2"
        app:layout_constraintVertical_bias="0.0" />
</android.support.constraint.ConstraintLayout>


text:
package com.overload.text;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;

import javax.swing.JLabel;
import javax.swing.border.EmptyBorder;
import javax.swing.text.JTextComponent;

/**
 * Handles prompts for text components that specify what the text component is for.
 * @author Odell
 */
public class PromptHandler implements FocusListener {

	private final JTextComponent textComp;
	private final JLabel overlay;

	private boolean enabled = false;

	/**
	 * Creates a new prompt handler for the given text component.
	 * @param textComp
	 * 		the text component to handle.
	 * @param text
	 * 		the text to prompt over the component.
	 */
	public PromptHandler(final JTextComponent textComp, final String text) {
		this(textComp, text, Color.LIGHT_GRAY);
	}

	/**
	 * Creates a new prompt handler for the given text component with a prompt color.
	 * @param textComp
	 * 		the text component to handle.
	 * @param text
	 * 		the text to prompt over the component.
	 * @param color
	 * 		the color of the prompt text.
	 */
	public PromptHandler(final JTextComponent textComp, final String text, final Color color) {
		if (textComp == null)
			throw new IllegalArgumentException("Component is null!");
		this.textComp = textComp;

		overlay = new JLabel();
		overlay.setText(text);
		overlay.setForeground(color);
		overlay.setFont(textComp.getFont());
		overlay.setBorder(new EmptyBorder(overlay.getInsets()));
		overlay.setHorizontalAlignment(JLabel.LEADING);

		textComp.setLayout(new BorderLayout());
		textComp.add(overlay);

		setEnabled(true);
		determinePrompt();
	}

	/**
	 * @return the text component that this PromptHandler is handling.
	 */
	public JTextComponent getComponent() {
		return textComp;
	}

	/**
	 * @return the prompt text currently in use.
	 */
	public String getText() {
		return overlay.getText();
	}

	/**
	 * Sets a new text as prompt text.
	 * @param text
	 * 		the new prompt text.
	 */
	public void setText(final String text) {
		this.overlay.setText(text);
	}

	/**
	 * @return the current color of the prompt text.
	 */
	public Color getColor() {
		return overlay.getForeground();
	}

	/**
	 * Sets a new text color for the prompt.
	 * @param color
	 * 		the new prompt text color.
	 */
	public void setColor(final Color color) {
		this.overlay.setForeground(color);
	}

	/**
	 * @return whether this prompt handler is active over the component.
	 */
	public boolean isEnabled() {
		return enabled;
	}

	/**
	 * Enables or disables prompt handling.
	 * @param enabled
	 * 		whether to enable or disable.
	 */
	public void setEnabled(final boolean enabled) {
		if (this.enabled == enabled)
			return;
		if (this.enabled = enabled) {
			textComp.addFocusListener(this);
		} else {
			setVisible(false);
			textComp.removeFocusListener(this);
		}
	}

	private boolean isVisible() {
		return overlay.isVisible();
	}

	private void setVisible(final boolean visible) {
		this.overlay.setVisible(visible);
	}

	private void determinePrompt() {
		if (textComp.hasFocus()) {
			if (isVisible()) {
				setVisible(false);
			}
		} else {
			if (textComp.getText().length() <= 0) {
				setVisible(true);
			}
		}
	}

	@Override
	public void focusGained(FocusEvent fe) {
		if (!textComp.equals(fe.getSource()))
			return;
		determinePrompt();
	}

	@Override
	public void focusLost(FocusEvent fe) {
		if (!textComp.equals(fe.getSource()))
			return;
		determinePrompt();
	}

}


text:
package org.apache.kafka.streams.tests;

import org.apache.kafka.common.utils.Utils;
import org.apache.kafka.streams.StreamsConfig;

import java.io.IOException;
import java.time.Duration;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.UUID;

import static org.apache.kafka.streams.tests.SmokeTestDriver.generate;
import static org.apache.kafka.streams.tests.SmokeTestDriver.generatePerpetually;

public class StreamsSmokeTest {

    /**
     *  args ::= kafka propFileName command disableAutoTerminate
     *  command := "run" | "process"
     *
     * @param args
     */
    public static void main(final String[] args) throws IOException {
        if (args.length < 2) {
            System.err.println("StreamsSmokeTest are expecting two parameters: propFile, command; but only see " + args.length + " parameter");
            System.exit(1);
        }

        final String propFileName = args[0];
        final String command = args[1];
        final boolean disableAutoTerminate = args.length > 2;

        final Properties streamsProperties = Utils.loadProps(propFileName);
        final String kafka = streamsProperties.getProperty(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG);

        if (kafka == null) {
            System.err.println("No bootstrap kafka servers specified in " + StreamsConfig.BOOTSTRAP_SERVERS_CONFIG);
            System.exit(1);
        }

        System.out.println("StreamsTest instance started (StreamsSmokeTest)");
        System.out.println("command=" + command);
        System.out.println("props=" + streamsProperties);
        System.out.println("disableAutoTerminate=" + disableAutoTerminate);

        switch (command) {
            case "run":
                // this starts the driver (data generation and result verification)
                final int numKeys = 10;
                final int maxRecordsPerKey = 500;
                if (disableAutoTerminate) {
                    generatePerpetually(kafka, numKeys, maxRecordsPerKey);
                } else {
                    // slow down data production to span 30 seconds so that system tests have time to
                    // do their bounces, etc.
                    final Map<String, Set<Integer>> allData =
                        generate(kafka, numKeys, maxRecordsPerKey, Duration.ofSeconds(30));
                    SmokeTestDriver.verify(kafka, allData, maxRecordsPerKey);
                }
                break;
            case "process":
                // this starts the stream processing app
                new SmokeTestClient(UUID.randomUUID().toString()).start(streamsProperties);
                break;
            case "process-eos":
                // this starts the stream processing app with EOS
                streamsProperties.setProperty(StreamsConfig.PROCESSING_GUARANTEE_CONFIG, StreamsConfig.EXACTLY_ONCE);
                new SmokeTestClient(UUID.randomUUID().toString()).start(streamsProperties);
                break;
            case "close-deadlock-test":
                final ShutdownDeadlockTest test = new ShutdownDeadlockTest(kafka);
                test.start();
                break;
            default:
                System.out.println("unknown command: " + command);
        }
    }

}


text:
<?php
namespace tests\presentation\responses\HttpResponseA;
use vsc\presentation\responses\HttpResponseA;
use vsc\presentation\responses\HttpResponseType;

/**
 * @covers \vsc\presentation\responses\HttpResponseA::getHttpStatusString()
 */
class getHttpStatusString extends \BaseUnitTest
{
	public function testGetHttpStatusString ()
	{
		$sProtocol = 'HTTP/1.1';
		$iStatus = HttpResponseType::ACCEPTED;
		$FullStatus = $sProtocol . ' ' . HttpResponseType::getStatus($iStatus);
		$this->assertEquals($FullStatus,  HttpResponseA_underTest_getHttpStatusString::getHttpStatusString($sProtocol, $iStatus));
	}
}

class HttpResponseA_underTest_getHttpStatusString extends HttpResponseA {}


text:
"""A more complex example of do/undo capability with PyTables.

Here, names has been assigned to the marks, and jumps are done between
marks.

"""

import tables

# Create an HDF5 file
fileh = tables.open_file('tutorial3-2.h5', 'w', title='Undo/Redo demo 2')

         #'-**-**-**-**-**-**- enable undo/redo log  -**-**-**-**-**-**-**-'
fileh.enable_undo()

# Start undoable operations
fileh.create_array('/', 'otherarray1', [3, 4], 'Another array 1')
fileh.create_group('/', 'agroup', 'Group 1')
# Create a 'first' mark
fileh.mark('first')
fileh.create_array('/agroup', 'otherarray2', [4, 5], 'Another array 2')
fileh.create_group('/agroup', 'agroup2', 'Group 2')
# Create a 'second' mark
fileh.mark('second')
fileh.create_array('/agroup/agroup2', 'otherarray3', [5, 6], 'Another array 3')
# Create a 'third' mark
fileh.mark('third')
fileh.create_array('/', 'otherarray4', [6, 7], 'Another array 4')
fileh.create_array('/agroup', 'otherarray5', [7, 8], 'Another array 5')

# Now go to mark 'first'
fileh.goto('first')
assert '/otherarray1' in fileh
assert '/agroup' in fileh
assert '/agroup/agroup2' not in fileh
assert '/agroup/otherarray2' not in fileh
assert '/agroup/agroup2/otherarray3' not in fileh
assert '/otherarray4' not in fileh
assert '/agroup/otherarray5' not in fileh
# Go to mark 'third'
fileh.goto('third')
assert '/otherarray1' in fileh
assert '/agroup' in fileh
assert '/agroup/agroup2' in fileh
assert '/agroup/otherarray2' in fileh
assert '/agroup/agroup2/otherarray3' in fileh
assert '/otherarray4' not in fileh
assert '/agroup/otherarray5' not in fileh
# Now go to mark 'second'
fileh.goto('second')
assert '/otherarray1' in fileh
assert '/agroup' in fileh
assert '/agroup/agroup2' in fileh
assert '/agroup/otherarray2' in fileh
assert '/agroup/agroup2/otherarray3' not in fileh
assert '/otherarray4' not in fileh
assert '/agroup/otherarray5' not in fileh
# Go to the end
fileh.goto(-1)
assert '/otherarray1' in fileh
assert '/agroup' in fileh
assert '/agroup/agroup2' in fileh
assert '/agroup/otherarray2' in fileh
assert '/agroup/agroup2/otherarray3' in fileh
assert '/otherarray4' in fileh
assert '/agroup/otherarray5' in fileh
# Check that objects have come back to life in a sane state
assert fileh.root.otherarray1.read() == [3, 4]
assert fileh.root.agroup.otherarray2.read() == [4, 5]
assert fileh.root.agroup.agroup2.otherarray3.read() == [5, 6]
assert fileh.root.otherarray4.read() == [6, 7]
assert fileh.root.agroup.otherarray5.read() == [7, 8]

         #'-**-**-**-**-**-**- disable undo/redo log  -**-**-**-**-**-**-**-'
fileh.disable_undo()

# Close the file
fileh.close()


text:
module Spree
  Variant.class_eval do

    has_many :experiences, through: :experience_variants
    has_many :experience_variants

    before_create :populate_for_experiences

    private

    durably_decorate :create_stock_items, mode: 'soft', sha: '98704433ac5c66ba46e02699f3cf03d13d4f1281' do
      StockLocation.all.each do |stock_location|
        if stock_location.experience_id.blank? || self.experiences.pluck(:id).include?(stock_location.experience_id)
          stock_location.propagate_variant(self) if stock_location.propagate_all_variants?
        end
      end
    end

    def populate_for_experiences
      self.experiences = self.product.experiences
    end

  end
end


text:
@echo off
:: Copyright 2019 The Chromium Authors. All rights reserved.
:: Use of this source code is governed by a BSD-style license that can be
:: found in the LICENSE file.

call "%~dp0\cipd_bin_setup.bat" > nul 2>&1
"%~dp0\.cipd_bin\bb.exe" %*


text:
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <item name="android.animation.AnimatorInflater android.animation.Animator loadAnimator(android.content.Context, int) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.AnimatorInflater android.animation.Animator loadAnimator(android.content.Context, int) 1">
    <annotation name="android.support.annotation.AnimatorRes" />
  </item>
  <item name="android.animation.AnimatorSet android.animation.AnimatorSet clone()">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.AnimatorSet android.animation.AnimatorSet setDuration(long)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.AnimatorSet java.util.ArrayList<android.animation.Animator> getChildAnimations()">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.AnimatorSet.Builder android.animation.AnimatorSet.Builder after(android.animation.Animator)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.AnimatorSet.Builder android.animation.AnimatorSet.Builder after(long)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.AnimatorSet.Builder android.animation.AnimatorSet.Builder before(android.animation.Animator)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.AnimatorSet.Builder android.animation.AnimatorSet.Builder with(android.animation.Animator)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ArgbEvaluator java.lang.Object evaluate(float, java.lang.Object, java.lang.Object)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.FloatEvaluator java.lang.Float evaluate(float, java.lang.Number, java.lang.Number)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.FloatEvaluator java.lang.Float evaluate(float, java.lang.Number, java.lang.Number) 1">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.FloatEvaluator java.lang.Float evaluate(float, java.lang.Number, java.lang.Number) 2">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.IntEvaluator java.lang.Integer evaluate(float, java.lang.Integer, java.lang.Integer)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.Keyframe android.animation.Keyframe ofFloat(float)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.Keyframe android.animation.Keyframe ofFloat(float, float)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.Keyframe android.animation.Keyframe ofInt(float)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.Keyframe android.animation.Keyframe ofInt(float, int)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.Keyframe android.animation.Keyframe ofObject(float, java.lang.Object)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.LayoutTransition void addChild(android.view.ViewGroup, android.view.View) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.LayoutTransition void hideChild(android.view.ViewGroup, android.view.View) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.LayoutTransition void hideChild(android.view.ViewGroup, android.view.View) 1">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.LayoutTransition void hideChild(android.view.ViewGroup, android.view.View, int) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.LayoutTransition void hideChild(android.view.ViewGroup, android.view.View, int) 1">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.LayoutTransition void removeChild(android.view.ViewGroup, android.view.View) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.LayoutTransition void removeChild(android.view.ViewGroup, android.view.View) 1">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.LayoutTransition void showChild(android.view.ViewGroup, android.view.View) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.LayoutTransition void showChild(android.view.ViewGroup, android.view.View, int) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator clone()">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofFloat(T, android.util.Property<T,java.lang.Float>, float...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofFloat(T, android.util.Property<T,java.lang.Float>, float...) 1">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofFloat(java.lang.Object, java.lang.String, float...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofInt(T, android.util.Property<T,java.lang.Integer>, int...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofInt(T, android.util.Property<T,java.lang.Integer>, int...) 1">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofInt(java.lang.Object, java.lang.String, int...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofObject(T, android.util.Property<T,P>, android.animation.TypeConverter<V,P>, android.animation.TypeEvaluator<V>, V...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofObject(T, android.util.Property<T,V>, android.animation.TypeConverter<android.graphics.PointF,V>, android.graphics.Path)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofObject(T, android.util.Property<T,V>, android.animation.TypeConverter<android.graphics.PointF,V>, android.graphics.Path) 1">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofObject(T, android.util.Property<T,V>, android.animation.TypeConverter<android.graphics.PointF,V>, android.graphics.Path) 2">
    <annotation name="android.support.annotation.Nullable" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofObject(T, android.util.Property<T,V>, android.animation.TypeEvaluator<V>, V...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofObject(T, android.util.Property<T,V>, android.animation.TypeEvaluator<V>, V...) 1">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofObject(java.lang.Object, java.lang.String, android.animation.TypeConverter<android.graphics.PointF,?>, android.graphics.Path)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofObject(java.lang.Object, java.lang.String, android.animation.TypeConverter<android.graphics.PointF,?>, android.graphics.Path) 2">
    <annotation name="android.support.annotation.Nullable" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofObject(java.lang.Object, java.lang.String, android.animation.TypeEvaluator, java.lang.Object...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator ofPropertyValuesHolder(java.lang.Object, android.animation.PropertyValuesHolder...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator android.animation.ObjectAnimator setDuration(long)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator java.lang.Object getTarget()">
    <annotation name="android.support.annotation.Nullable" />
  </item>
  <item name="android.animation.ObjectAnimator java.lang.String getPropertyName()">
    <annotation name="android.support.annotation.Nullable" />
  </item>
  <item name="android.animation.ObjectAnimator void setProperty(android.util.Property) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator void setPropertyName(java.lang.String) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ObjectAnimator void setTarget(java.lang.Object) 0">
    <annotation name="android.support.annotation.Nullable" />
  </item>
  <item name="android.animation.PropertyValuesHolder android.animation.PropertyValuesHolder ofFloat(android.util.Property<?,java.lang.Float>, float...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.PropertyValuesHolder android.animation.PropertyValuesHolder ofFloat(java.lang.String, float...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.PropertyValuesHolder android.animation.PropertyValuesHolder ofInt(android.util.Property<?,java.lang.Integer>, int...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.PropertyValuesHolder android.animation.PropertyValuesHolder ofInt(java.lang.String, int...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.PropertyValuesHolder android.animation.PropertyValuesHolder ofKeyframe(android.util.Property, android.animation.Keyframe...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.PropertyValuesHolder android.animation.PropertyValuesHolder ofKeyframe(java.lang.String, android.animation.Keyframe...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.PropertyValuesHolder android.animation.PropertyValuesHolder ofObject(android.util.Property, android.animation.TypeEvaluator<V>, V...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.PropertyValuesHolder android.animation.PropertyValuesHolder ofObject(java.lang.String, android.animation.TypeEvaluator, java.lang.Object...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.PropertyValuesHolder void setKeyframes(android.animation.Keyframe...) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ValueAnimator android.animation.ValueAnimator ofFloat(float...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ValueAnimator android.animation.ValueAnimator ofInt(int...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ValueAnimator android.animation.ValueAnimator ofObject(android.animation.TypeEvaluator, java.lang.Object...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ValueAnimator android.animation.ValueAnimator ofPropertyValuesHolder(android.animation.PropertyValuesHolder...)">
    <annotation name="android.support.annotation.NonNull" />
  </item>
  <item name="android.animation.ValueAnimator void setValues(android.animation.PropertyValuesHolder...) 0">
    <annotation name="android.support.annotation.NonNull" />
  </item>
</root>