text:
package com.bullhornsdk.data.model.response.list;

import com.bullhornsdk.data.model.entity.core.paybill.master.BillingSyncBatch;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({"data", "count", "start"})
public class BillingSyncBatchListWrapper extends StandardListWrapper<BillingSyncBatch> {

}


text:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.ar4android.locationAccessJME"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="9"
        android:targetSdkVersion="17" />
    <uses-feature android:required="true" android:glEsVersion="0x00020000"/>
    <uses-permission android:name="android.permission.CAMERA" />
	<uses-feature android:name="android.hardware.camera" />
	<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
	<uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION"/>
	<uses-permission android:name="android.permission.INTERNET"/>
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.ar4android.locationAccessJME.LocationAccessJMEActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

redpajama_set_name: RedPajamaGithub


text:
/**
 * Support and FAQ: visit Atmel Support
 */

#ifndef CONF_BOARD_H
#define CONF_BOARD_H

// Enabled when Zigbit Extension board is used
//# define ZIGBIT_EXT

// Enabled when Zigbit USB-Extension board is used
//#define ZIGBIT_USB

#endif // CONF_BOARD_H


text:
<?php

namespace Dafiti\Correios\Validator;

class BooleanTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @dataProvider validationProvider
     */
    public function testValidation($value, $result)
    {
        $validator = new Boolean(null);
        $this->assertEquals($result, $validator->validate($value));
    }

    public function validationProvider()
    {
        return [
            [true,true],
            [1, "Field is not a boolean."],
            [0, "Field is not a boolean."],
            [false, true],
            [null, "Field is not a boolean."]
        ];
    }
}


text:
'use strict';

var Lib = require('../../lib');
var contrast = require('../../components/color').contrast;
var layoutAttributes = require('./layout_attributes');
var getShowAttrDflt = require('./show_dflt');
var handleArrayContainerDefaults = require('../array_container_defaults');

module.exports = function handleTickLabelDefaults(containerIn, containerOut, coerce, axType, options) {
    if(!options) options = {};
    var showAttrDflt = getShowAttrDflt(containerIn);

    var showTickLabels = coerce('showticklabels');
    if(showTickLabels) {
        var font = options.font || {};
        var contColor = containerOut.color;
        var position = containerOut.ticklabelposition || '';
        var dfltFontColor = position.indexOf('inside') !== -1 ?
            contrast(options.bgColor) :
            // as with titlefont.color, inherit axis.color only if one was
            // explicitly provided
            (contColor && contColor !== layoutAttributes.color.dflt) ?
            contColor : font.color;

        Lib.coerceFont(coerce, 'tickfont', {
            family: font.family,
            size: font.size,
            color: dfltFontColor
        });

        if(
            !options.noTicklabelstep &&
            axType !== 'multicategory' &&
            axType !== 'log'
        ) {
            coerce('ticklabelstep');
        }

        if(!options.noAng) coerce('tickangle');

        if(axType !== 'category') {
            var tickFormat = coerce('tickformat');

            handleArrayContainerDefaults(containerIn, containerOut, {
                name: 'tickformatstops',
                inclusionAttr: 'enabled',
                handleItemDefaults: tickformatstopDefaults
            });
            if(!containerOut.tickformatstops.length) {
                delete containerOut.tickformatstops;
            }

            if(!options.noExp && !tickFormat && axType !== 'date') {
                coerce('showexponent', showAttrDflt);
                coerce('exponentformat');
                coerce('minexponent');
                coerce('separatethousands');
            }
        }
    }
};

function tickformatstopDefaults(valueIn, valueOut) {
    function coerce(attr, dflt) {
        return Lib.coerce(valueIn, valueOut, layoutAttributes.tickformatstops, attr, dflt);
    }

    var enabled = coerce('enabled');
    if(enabled) {
        coerce('dtickrange');
        coerce('value');
    }
}


text:
package indirectkeyfiles

import (
	"context"
	"crypto"
	"encoding/pem"
	"fmt"
	"os"

	"v.io/x/ref/lib/security/keys"
)

// MustRegister is like Register but panics on error.
func MustRegister(r *keys.Registrar) {
	if err := Register(r); err != nil {
		panic(err)
	}
}

const indirectHeaderValue = "filename"

// Register registers the required functions for handling indirect key files
// via the x/ref/security/keys package.
func Register(r *keys.Registrar) error {
	r.RegisterIndirectPrivateKeyParser(parsePrivateKeyFile, indirectHeaderValue)
	return nil
}

// MarshalPrivateKey marshals a filename into the PEM block suitable
// for parsing by this package.
var MarshalPrivateKey = keys.MarshalFuncForIndirection(indirectHeaderValue)

type indirection struct {
	filename string
	data     []byte
}

// Next implements keys.Indirection.
func (i *indirection) Next(ctx context.Context, passphrase []byte) (crypto.PrivateKey, []byte) {
	return nil, i.data
}

// String implements keys.Indirection.
func (i *indirection) String() string {
	return fmt.Sprintf("filename: %v", i.filename)
}

func parsePrivateKeyFile(pem *pem.Block) (crypto.PrivateKey, error) {
	filename := string(pem.Bytes)
	data, err := os.ReadFile(filename)
	if err != nil {
		return nil, fmt.Errorf("failed to read filename in %q: %v", pem.Type, err)
	}
	return &indirection{filename: filename, data: data}, nil
}


text:
module(..., package.seeall)

local common = require("program.config.common")

function run(args)
   args = common.parse_command_line(
      args, { command='remove', with_path=true, is_config=true })
   local response = common.call_leader(
      args.instance_id, 'remove-config',
      { schema = args.schema_name, revision = args.revision_date,
        path = args.path })
   -- The reply is empty.
   common.print_and_exit(response)
end


text:
@protocol IScriptWriter < NSObject >
- (void)close;
- (void)dispose;
- (void)flushStream;
- (void)writeWithBoolean:(BOOL)value;
- (void)writeWithByte:(char)value;
- (void)writeByteValWithByteArray:(NSData *)buffer;
- (void)writeBytesWithByteArray:(Byte *)buffer
                        withInt:(int)index
                        withInt:(int)count;
- (void)writeWithChar:(unichar)ch;
- (void)writeWithCharArray:(Byte *)chars;
- (void)writeWithDouble:(double)value;
- (void)writeWithShort:(short int)value;
- (void)writeIntValWithInt:(int)value;
- (void)writeWithLong:(long)value;
- (void)writeWithFloat:(float)value;
- (void)writeWithNSString:(NSString *)value;
- (NSData *)getBaseStream;
@end

#endif // _IScriptWriter_H_


text:
<?php
namespace App;

use Command\CommandContext;
use Command\Command;

class ControllerApp
{
  private $command;
  private $context;

  public function __construct(CommandContext $context)
  {
    $this->context = $context;
  }

  public function execute(Command $command, $view = '', $dados = array())
  {
    $this->context->param('view', $view);
    $this->context->param('dados', $dados);
    return $command->execute($this->context);
  }
}


text:
# `ExceptionTrace`: point of exception

The class `axy\backtrace\ExceptionTrace` extends the class [Trace](Trace.md).

An instance of this class, in addition to the stack, also contains a reference to the line where the exception occurred.

### `__construct([array $items [, string $file, int $line])`

 * `$items` - see [Trace](Trace.md)
 * `$file` and `$line` - the place where the exception occured.

This is the data that can be received using `$e->getTrace()`, `$e->getFile()` and `$e->getLine()`.

If no arguments are given, a point of the instance creation will be taken.

```php
/* File /test/index.php */
use axy\backtrace\ExceptionTrace;

function one()
{
    return two();
}

function two()
{
    return new ExceptionTrace(); // line 15
}

$trace = one();

echo 'File: '.$trace->file.\PHP_EOL;
echo 'Line: '.$trace->line.\PHP_EOL;
echo $trace;
```

The output:
```php
File: /test/index.php
Line: 15
#0 /test/index.php(10): two()
#1 /test/index.php(18): one()
#2 {main}
```

If you specify `$items`, but do not specify `$file` and `$line`, they are taken from the current call.

### Properties (read-only)

Inherited from [Trace](Trace.md):

 * `$items`
 * `$originalItems`

New:

 * `$file`
 * `$line`
 * `$originalFile`
 * `$originalLine`

`$original*` can not be modified.
The others can be modified by methods.

### `truncate*`

See [Trace::truncate()](truncate.md).

In additional, `$file` and `$line` are changed to point to the entry point into the library.

### `trimFilename(string $dir)`

In additional, trims the `$file`.


text:
package com.example.jingbin.cloudreader.ui.book;

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.design.widget.TabLayout;
import android.support.v4.app.Fragment;

import com.example.jingbin.cloudreader.R;
import com.example.jingbin.cloudreader.base.BaseFragment;
import com.example.jingbin.cloudreader.databinding.FragmentBookBinding;
import com.example.jingbin.cloudreader.ui.book.child.BookCustomFragment;
import com.example.jingbin.cloudreader.view.MyFragmentPagerAdapter;

import java.util.ArrayList;

/**
 * Created by jingbin on 16/12/14.
 * 展示书籍的页面
 */
public class BookFragment extends BaseFragment<FragmentBookBinding> {

    private ArrayList<String> mTitleList = new ArrayList<>(3);
    private ArrayList<Fragment> mFragments = new ArrayList<>(3);

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        showLoading();
        initFragmentList();
        /**
         * 注意使用的是:getChildFragmentManager,
         * 这样setOffscreenPageLimit()就可以添加上,保留相邻2个实例,切换时不会卡
         * 但会内存溢出,在显示时加载数据
         */
        MyFragmentPagerAdapter myAdapter = new MyFragmentPagerAdapter(getChildFragmentManager(), mFragments, mTitleList);
        bindingView.vpBook.setAdapter(myAdapter);
        // 左右预加载页面的个数
        bindingView.vpBook.setOffscreenPageLimit(2);
        myAdapter.notifyDataSetChanged();
        bindingView.tabBook.setTabMode(TabLayout.MODE_FIXED);
        bindingView.tabBook.setupWithViewPager(bindingView.vpBook);
        showContentView();
    }

    @Override
    public int setContent() {
        return R.layout.fragment_book;
    }

    private void initFragmentList() {
        mTitleList.add("文学");
        mTitleList.add("文化");
        mTitleList.add("生活");
        mFragments.add(BookCustomFragment.newInstance("文学"));
        mFragments.add(BookCustomFragment.newInstance("文化"));
        mFragments.add(BookCustomFragment.newInstance("生活"));
    }
}


text:
<?php

/**
 * Config settings for the YouTube Video
 */
return array(

	/**
	 * Whether the YouTube field is shown in the administrator config, and whether it's set for the seed
	 */
	'show' => true,

	/**
	 * YouTube Embed Player code used if an item has a You Tube Video ID set
	 * instead of a Main Image. Changing the settings will apply to all items that
	 * have a You Tube Video on them. The placeholder "%YOU_TUBE_VIDEO_ID%" is
	 * replaced with the You Tube Video ID in the database for this item.
	 */
	'embed_code' => '',

	/**
	 * YouTube Thumbnail code used if an item has a You Tube Video ID set instead of a Main Image. Changing the
	 * settings will apply to all entries on the index pages for items that have a You Tube Video. The
	 * placeholder "%YOU_TUBE_VIDEO_ID%" is replaced with the You Tube Video ID in the database for this item.
	 */
	'thumbnail_code' => '',

);


text:
#include "base/unix_file/string_file.h"
#include <errno.h>
#include <algorithm>
#include "base/logging.h"

namespace unix_file {

StringFile::StringFile() {
}

StringFile::~StringFile() {
}

int StringFile::Close() {
  return 0;
}

int StringFile::Flush() {
  return 0;
}

int64_t StringFile::Read(char *buf, int64_t byte_count, int64_t offset) const {
  CHECK(buf);
  CHECK_GE(byte_count, 0);

  if (offset < 0) {
    return -EINVAL;
  }

  const int64_t available_bytes = std::min(byte_count, GetLength() - offset);
  if (available_bytes < 0) {
    return 0;  // Not an error, but nothing for us to do, either.
  }
  memcpy(buf, data_.data() + offset, available_bytes);
  return available_bytes;
}

int StringFile::SetLength(int64_t new_length) {
  if (new_length < 0) {
    return -EINVAL;
  }
  data_.resize(new_length);
  return 0;
}

int64_t StringFile::GetLength() const {
  return data_.size();
}

int64_t StringFile::Write(const char *buf, int64_t byte_count, int64_t offset) {
  CHECK(buf);
  CHECK_GE(byte_count, 0);

  if (offset < 0) {
    return -EINVAL;
  }

  if (byte_count == 0) {
    return 0;
  }

  // FUSE seems happy to allow writes past the end. (I'd guess it doesn't
  // synthesize a write of zero bytes so that we're free to implement sparse
  // files.) GNU as(1) seems to require such writes. Those files are small.
  const int64_t bytes_past_end = offset - GetLength();
  if (bytes_past_end > 0) {
    data_.append(bytes_past_end, '\0');
  }

  data_.replace(offset, byte_count, buf, byte_count);
  return byte_count;
}

void StringFile::Assign(const art::StringPiece &new_data) {
  data_.assign(new_data.data(), new_data.size());
}

const art::StringPiece StringFile::ToStringPiece() const {
  return data_;
}

}  // namespace unix_file


text:
  `with <span class="badge badge-secondary rows-num"></span> checked rows:`

  <input type="submit" name="delete" value="`Delete`" class="btn btn-danger on-delete-multi">
  <~btn_multidel_more>


text:
/**
 * Module dependencies.
 */

const uubench = require('uubench')

/* global suite:writable */
suite = new uubench.Suite({
  start: function () {
    console.log()
  },

  result: function (name, stats) {
    const persec = 1000 / stats.elapsed
    const ops = stats.iterations * persec
    console.log('%s : %s ops/s', name, ops | 0)
  },

  done: function () {
    console.log()
  }
})

require('./metaphone')
require('./soundex')
require('./stemmer_id')

suite.run()


text:
from __future__ import print_function

import signal

from . import base
from testrunner.local import utils

class SignalProc(base.TestProcObserver):
  def __init__(self):
    super(SignalProc, self).__init__()
    self.exit_code = utils.EXIT_CODE_PASS

  def setup(self, *args, **kwargs):
    super(SignalProc, self).setup(*args, **kwargs)
    # It should be called after processors are chained together to not loose
    # catched signal.
    signal.signal(signal.SIGINT, self._on_ctrlc)
    signal.signal(signal.SIGTERM, self._on_sigterm)

  def _on_ctrlc(self, _signum, _stack_frame):
    print('>>> Ctrl-C detected, early abort...')
    self.exit_code = utils.EXIT_CODE_INTERRUPTED
    self.stop()

  def _on_sigterm(self, _signum, _stack_frame):
    print('>>> SIGTERM received, early abort...')
    self.exit_code = utils.EXIT_CODE_TERMINATED
    self.stop()


text:
package edu.internet2.middleware.openid.extensions.ax.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import edu.internet2.middleware.openid.extensions.ax.FetchRequest;

/**
 * Implementation of {@link FetchRequest} attribute exchange messages.
 */
public class FetchRequestImpl extends BaseAttributeExchangeMessage implements FetchRequest {

    /**
     * Optional attributes.
     */
    private List<String> optionalAttributes;

    /**
     * Required attributes.
     */
    private List<String> requiredAttributes;

    /**
     * Map of requested number of values for each attribute.
     */
    private Map<String, Integer> attributeCount;

    /**
     * Update URL.
     */
    private String updateURL;

    /**
     * Constructor.
     */
    public FetchRequestImpl() {
        optionalAttributes = new ArrayList<String>();
        requiredAttributes = new ArrayList<String>();
        attributeCount = new HashMap<String, Integer>();
    }

    /** {@inheritDoc} */
    public String getMode() {
        return FetchRequest.MODE;
    }

    /** {@inheritDoc} */
    public List<String> getOptionalAttributes() {
        return optionalAttributes;
    }

    /** {@inheritDoc} */
    public List<String> getRequiredAttributes() {
        return requiredAttributes;
    }

    /** {@inheritDoc} */
    public Map<String, Integer> getAttributeCount() {
        return attributeCount;
    }

    /** {@inheritDoc} */
    public String getUpdateURL() {
        return updateURL;
    }

    /** {@inheritDoc} */
    public void setUpdateURL(String newUpdateURL) {
        updateURL = newUpdateURL;
    }

}


text:
layout: page
header:
  title: Soroka Clinical Research Center
  image_fullwidth: microdude.jpg
title: "Grants"
meta_title: "Grantss"
subheadline: ""
teaser: ""
permalink: "/Grantss/"
---
<link rel="stylesheet" href="{{site.urlass}}/timeline/reset.css">
<link rel="stylesheet" href="{{site.urlass}}/timeline/style.css">

	{% for grant in site.data.grants %}

			{% if grant.img contains 'picture' %}

			{% elsif grant.img contains 'movie' %}

			{% else %}

			{% endif %}

{{ grant.title }}

{{ grant.source }}.

PI - {{ grant.PIdr }}.

				{{ grant.date }}

 	{% endfor %}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Mycologia 7(5): 273 (1915)

#### Original name
Clitocybe submarmorea Murrill

### Remarks
null


text:
var jschardet = exports;

require('./constants');
require('./codingstatemachine');
require('./escsm');
require('./mbcssm');
require('./charsetprober');
require('./mbcharsetprober');
require('./jisfreq');
require('./gb2312freq');
require('./euckrfreq');
require('./big5freq');
require('./euctwfreq');
require('./chardistribution');
require('./jpcntx');
require('./sjisprober');
require('./utf8prober');
require('./charsetgroupprober');
require('./eucjpprober');
require('./gb2312prober');
require('./euckrprober');
require('./big5prober');
require('./euctwprober');
require('./mbcsgroupprober');
require('./sbcharsetprober');
require('./langgreekmodel');
require('./langthaimodel');
require('./langbulgarianmodel');
require('./langcyrillicmodel');
require('./hebrewprober');
require('./langhebrewmodel');
require('./langhungarianmodel');
require('./sbcsgroupprober');
require('./latin1prober');
require('./escprober');
require('./universaldetector');

jschardet.VERSION = "1.4.1";
jschardet.detect = function(buffer) {
    var u = new jschardet.UniversalDetector();
    u.reset();
    if( typeof Buffer == 'function' && buffer instanceof Buffer ) {
        u.feed(buffer.toString('binary'));
    } else {
        u.feed(buffer);
    }
    u.close();
    return u.result;
}
jschardet.log = function() {
  console.log.apply(console, arguments);
}


text:
package org.apache.lucene.index;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.apache.lucene.util.LuceneTestCase;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.FSDirectory;

/**
 * This tests the patch for issue #LUCENE-715 (IndexWriter does not
 * release its write lock when trying to open an index which does not yet
 * exist).
 *
 * @version $Id$
 */

public class TestIndexWriterLockRelease extends LuceneTestCase {
    private java.io.File __test_dir;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        if (this.__test_dir == null) {
            String tmp_dir = System.getProperty("java.io.tmpdir", "tmp");
            this.__test_dir = new File(tmp_dir, "testIndexWriter");

            if (this.__test_dir.exists()) {
                throw new IOException("test directory \"" + this.__test_dir.getPath() + "\" already exists (please remove by hand)");
            }

            if (!this.__test_dir.mkdirs()
                && !this.__test_dir.isDirectory()) {
                throw new IOException("unable to create test directory \"" + this.__test_dir.getPath() + "\"");
            }
        }
    }

    @Override
    public void tearDown() throws Exception {
        super.tearDown();
        if (this.__test_dir != null) {
            File[] files = this.__test_dir.listFiles();

            for (int i = 0;
                i < files.length;
                ++i) {
                if (!files[i].delete()) {
                    throw new IOException("unable to remove file in test directory \"" + this.__test_dir.getPath() + "\" (please remove by hand)");
                }
            }

            if (!this.__test_dir.delete()) {
                throw new IOException("unable to remove test directory \"" + this.__test_dir.getPath() + "\" (please remove by hand)");
            }
        }
    }

    public void testIndexWriterLockRelease() throws IOException {
        IndexWriter im;
        FSDirectory dir = FSDirectory.open(this.__test_dir);
        try {
            im = new IndexWriter(dir, new org.apache.lucene.analysis.standard.StandardAnalyzer(org.apache.lucene.util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
        } catch (FileNotFoundException e) {
            try {
                im = new IndexWriter(dir, new org.apache.lucene.analysis.standard.StandardAnalyzer(org.apache.lucene.util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
            } catch (FileNotFoundException e1) {
            }
        } finally {
          dir.close();
        }
    }
}


text:
import lib.puylogger
import lib.record_rate
import lib.getconfig
import lib.commonclient
import lib.basecheck
import json
import socket

couchdb_url = lib.getconfig.getparam('CouchDB2', 'stats')
couchdb_auth = lib.getconfig.getparam('CouchDB2', 'user')+':'+lib.getconfig.getparam('CouchDB2', 'pass')
curl_auth = lib.getconfig.getparam('CouchDB2', 'auth')
detailed = lib.getconfig.getparam('CouchDB2', 'detailed')

cluster_name = lib.getconfig.getparam('SelfConfig', 'cluster_name')
check_type = 'couchdb'

dbops = ['database_writes', 'database_reads', 'document_inserts', 'document_writes']
httpd = ['bulk_requests', 'requests', 'temporary_view_reads', 'view_reads']

class Check(lib.basecheck.CheckBase):

    def precheck(self):
        try:

            memberslist = json.loads(lib.commonclient.httpget(__name__, couchdb_url + '/_membership', couchdb_auth))

            for couch in memberslist['all_nodes']:
                try:
                    nodename = socket.gethostbyaddr(couch.split('@')[1])[0]

                except:
                    nodename = couch.split('@')[1]

                metrics = json.loads(lib.commonclient.httpget(__name__, couchdb_url + '/_node/' + couch + '/_stats', couchdb_auth))

                for dbop in dbops:
                    reqrate = self.rate.record_value_rate(nodename + '_couchdb_' + dbop, metrics['couchdb'][dbop]['value'], self.timestamp)
                    self.local_vars.append({'name': 'couchdb_' + dbop, 'host': nodename, 'timestamp': self.timestamp, 'value': int(reqrate), 'check_type': check_type})

                for h in httpd:
                    reqrate = self.rate.record_value_rate(nodename + '_couchdb_' + h, metrics['couchdb']['httpd'][h]['value'], self.timestamp)
                    self.local_vars.append({'name': 'couchdb_' + h, 'host': nodename, 'timestamp': self.timestamp, 'value': int(reqrate), 'check_type': check_type})
                if detailed:
                    for m in metrics['couchdb']['httpd_request_methods'].keys():
                        reqrate = self.rate.record_value_rate(nodename + '_couchdb_' + m, metrics['couchdb']['httpd_request_methods'][m]['value'], self.timestamp)
                        self.local_vars.append({'name': 'couchdb_requests_methods', 'host': nodename, 'timestamp': self.timestamp, 'value': int(reqrate), 'check_type': check_type, 'extra_tag': {'method': m.lower()}})
                    for c in metrics['couchdb']['httpd_status_codes'].keys():
                        reqrate = self.rate.record_value_rate(nodename + '_couchdb_' + str(c), metrics['couchdb']['httpd_status_codes'][c]['value'], self.timestamp)
                        self.local_vars.append({'name': 'couchdb_status_codes', 'host': nodename, 'timestamp': self.timestamp, 'value': int(reqrate), 'check_type': check_type, 'extra_tag': {'method': c}})

        except Exception as e:
            lib.puylogger.print_message(__name__ + ' Error : ' + str(e))
            pass


text:
package pl.edu.agh.planner.utils;

import org.dozer.DozerBeanMapper;
import org.dozer.DozerBeanMapperSingletonWrapper;
import org.dozer.Mapper;
import pl.edu.agh.planner.domain.*;
import pl.edu.agh.planner.dto.*;

//@Component
public class DtoEntityMapper {

    private static Mapper mapper = (DozerBeanMapper) DozerBeanMapperSingletonWrapper.getInstance();

    public static AggregateEntity aggregateToEntity(Aggregate aggregate) {
        return mapper.map(aggregate, AggregateEntity.class);
    }

    public static Aggregate entityToAggregate(AggregateEntity aggregateEntity) {
        return mapper.map(aggregateEntity, Aggregate.class);
    }

    public static BuildingEntity buildingToEntity(Building building) {
        return mapper.map(building, BuildingEntity.class);
    }

    public static Building entityToBuilding(BuildingEntity buildingEntity) {
        return mapper.map(buildingEntity, Building.class);
    }

    public static AuthorizationEntity authorizationToEntity(DozerBeanMapper mapper, Authorization authorization) {
        return mapper.map(authorization, AuthorizationEntity.class);
    }

    public static AuthorizationEntity authorizationToEntity(Authorization authorization) {
        return mapper.map(authorization, AuthorizationEntity.class);
    }

    public static AuthorizationTypeEntity authorizationTypeToEntity(AuthorizationType authorizationType) {
        return mapper.map(authorizationType, AuthorizationTypeEntity.class);
    }

    public static AvatarEntity avatarToEntity(Avatar avatar) {
        return mapper.map(avatar, AvatarEntity.class);
    }

    public static Avatar entityToAvatar(AvatarEntity avatar) {
        return mapper.map(avatar, Avatar.class);
    }

    public static StudentGroup entityToStudentGroup(StudentGroupEntity entity) {
        return mapper.map(entity, StudentGroup.class);
    }

    public static StudentGroupEntity studentGroupToEntity(StudentGroup studentGroup) {
        return mapper.map(studentGroup, StudentGroupEntity.class);
    }

    public static ClassroomEntity classroomToEntity(Classroom classroom) {
        return mapper.map(classroom, ClassroomEntity.class);
    }

    public static ConcreteDateEntity concreteDateToEntity(ConcreteDate concreteDate) {
        return mapper.map(concreteDate, ConcreteDateEntity.class);
    }

    public static ConcreteDateTemplateEntity concreteDateTemplateToEntity(ConcreteDateTemplate concreteDateTemplate) {
        return mapper.map(concreteDateTemplate, ConcreteDateTemplateEntity.class);
    }

    public static ConcreteLessonEntity concreteLessonToEntity(ConcreteLesson concreteLesson) {
        return mapper.map(concreteLesson, ConcreteLessonEntity.class);
    }

    public static ConcreteLesson entityToConcreteLesson(ConcreteLessonEntity concreteLessonEntity) {
        return mapper.map(concreteLessonEntity, ConcreteLesson.class);
    }

    public static ConcreteDate entityToConcreteDate(ConcreteDateEntity concreteDateEntity) {
        return mapper.map(concreteDateEntity, ConcreteDate.class);
    }

    public static DepartmentEntity departmentToEntity(Department department) {
        return mapper.map(department, DepartmentEntity.class);
    }

    public static FacultyEntity facultyToEntity(Faculty faculty) {
        return mapper.map(faculty, FacultyEntity.class);
    }

    public static LetterDesignationEntity letterDesignationEntity(LetterDesignation letterDesignation) {
        return mapper.map(letterDesignation, LetterDesignationEntity.class);
    }

    public static ProgrammeUnit entityToProgrammeUnit(ProgrammeUnitEntity programmeUnitEntity) {
        return mapper.map(programmeUnitEntity, ProgrammeUnit.class);
    }

    public static ProgrammeUnitEntity programmeUnitToEntity(ProgrammeUnit programmeUnit) {
        return mapper.map(programmeUnit, ProgrammeUnitEntity.class);
    }

    public static ProgrammeUnitTypeEntity programmeUnitTypeToEntity(ProgrammeUnitType programmeUnitType) {
        return mapper.map(programmeUnitType, ProgrammeUnitTypeEntity.class);
    }

    public static ScheduleEntity scheduleToEntity(Schedule schedule) {
        return mapper.map(schedule, ScheduleEntity.class);
    }

    public static Schedule entityToSchedule(ScheduleEntity entity) {
        return mapper.map(entity, Schedule.class);
    }

    public static TeacherEntity teacherToEntity(Teacher teacher) {
        return mapper.map(teacher, TeacherEntity.class);
    }

    public static Teacher entityToTeacher(TeacherEntity teacherEntityher) {
        return mapper.map(teacherEntityher, Teacher.class);
    }

    public static TermsSetEntity termsSetToEntity(TermsSet termsSet) {
        return mapper.map(termsSet, TermsSetEntity.class);
    }

    public static UserEntity userToEntity(User user) {
        return mapper.map(user, UserEntity.class);
    }

    public static ViewEntity viewToEntity(View view) {
        return mapper.map(view, ViewEntity.class);
    }

    public static View entityToView(ViewEntity viewEntity) {
        return mapper.map(viewEntity, View.class);
    }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SessionM.MMC.models.intefaces
{
    interface ISMModel
    {
    }
}


text:
    Number:
    <input type="text" id="guess-number-input"/>
    <button id="make-guess-button">Make Guess</button>


text:
package org.jivesoftware.smackx.muc.packet;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.jivesoftware.smack.packet.IQ;

/**
 * IQ stanza(/packet) that serves for kicking users, granting and revoking voice, banning users,
 * modifying the ban list, granting and revoking membership and granting and revoking
 * moderator privileges. All these operations are scoped by the
 * 'http://jabber.org/protocol/muc#admin' namespace.
 *
 * @author Gaston Dombiak
 */
public class MUCAdmin extends IQ {

    public static final String ELEMENT = QUERY_ELEMENT;
    public static final String NAMESPACE = MUCInitialPresence.NAMESPACE + "#admin";

    private final List<MUCItem> items = new ArrayList<>();

    public MUCAdmin() {
        super(ELEMENT, NAMESPACE);
    }

    /**
     * Returns a List of item children that holds information about roles, affiliation,
     * jids and nicks.
     *
     * @return a List of item children that holds information about roles, affiliation,
     *          jids and nicks.
     */
    public List<MUCItem> getItems() {
        synchronized (items) {
            return Collections.unmodifiableList(new ArrayList<>(items));
        }
    }

    /**
     * Adds an item child that holds information about roles, affiliation, jids and nicks.
     *
     * @param item the item child that holds information about roles, affiliation, jids and nicks.
     */
    public void addItem(MUCItem item) {
        synchronized (items) {
            items.add(item);
        }
    }

    @Override
    protected IQChildElementXmlStringBuilder getIQChildElementBuilder(IQChildElementXmlStringBuilder xml) {
        xml.rightAngleBracket();

        synchronized (items) {
            for (MUCItem item : items) {
                xml.append(item.toXML());
            }
        }

        return xml;
    }
}


text:
require File.dirname(__FILE__) + '/../../test_helper'
require 'sass/util/normalized_map'

class NormalizedMapTest < Test::Unit::TestCase
  extend PublicApiLinter

  lint_api Hash, Sass::Util::NormalizedMap

  def lint_instance
    Sass::Util::NormalizedMap.new
  end

  def test_normalized_map_errors_unless_explicitly_implemented
    assert Sass.tests_running
    assert_raise_message(ArgumentError, "The method invert must be implemented explicitly") do
      Sass::Util::NormalizedMap.new.invert
    end
  end

  def test_normalized_map_does_not_error_when_released
    Sass.tests_running = false
    assert_equal({}, Sass::Util::NormalizedMap.new.invert)
  ensure
    Sass.tests_running = true
  end

  def test_basic_lifecycle
    m = Sass::Util::NormalizedMap.new
    m["a-b"] = 1
    assert_equal ["a_b"], m.keys
    assert_equal 1, m["a_b"]
    assert_equal 1, m["a-b"]
    assert m.has_key?("a_b")
    assert m.has_key?("a-b")
    assert_equal({"a-b" => 1}, m.as_stored)
    assert_equal 1, m.delete("a-b")
    assert !m.has_key?("a-b")
    m["a_b"] = 2
    assert_equal({"a_b" => 2}, m.as_stored)
  end

  def test_dup
    m = Sass::Util::NormalizedMap.new
    m["a-b"] = 1
    m2 = m.dup
    m.delete("a-b")
    assert !m.has_key?("a-b")
    assert m2.has_key?("a-b")
  end
end


text:
import unittest

import numpy as np

import paddle
import paddle.fluid.core as core
from paddle.fluid.tests.unittests.mkldnn.test_matmul_mkldnn_op import (
    TestMatMulOpTransposeReshapeBasicFloat,
    TestMatMulOpTransposeReshapeEmptyFloat,
    TestMatMulOpTransposeReshapeOtherDimFloat,
    TestReshapeTransposeMatMulOp,
    TestReshapeTransposeMatMulOp2DXFloat,
    TestReshapeTransposeMatMulOp2DYFloat,
    TestReshapeTransposeMatMulOp3DXFloat,
    TestReshapeTransposeMatMulOp3DYFloat,
    TestReshapeTransposeMatMulOp4DXFloat,
    TestReshapeTransposeMatMulOp4DXYFloat,
    TestReshapeTransposeMatMulOp4DYFloat,
)
from paddle.fluid.tests.unittests.op_test import (
    OpTest,
    OpTestTool,
    convert_float_to_uint16,
)

def reference_matmul(X, Y, transpose_x=False, transpose_y=False):
    """Reference forward implementation using np.matmul."""
    # np.matmul does not support the transpose flags, so we manually
    # transpose X and Y appropriately.
    if transpose_x:
        if X.ndim == 1:
            X = X.reshape((X.size,))
        elif X.ndim == 2:
            X = X.T
        else:
            dim = [i for i in range(len(X.shape))]
            dim[-1], dim[len(X.shape) - 2] = dim[len(X.shape) - 2], dim[-1]
            X = np.transpose(X, tuple(dim))
    if transpose_y:
        if Y.ndim == 1:
            Y = Y.reshape((Y.size,))
        else:
            dim = [i for i in range(len(Y.shape))]
            dim[-1], dim[len(Y.shape) - 2] = dim[len(Y.shape) - 2], dim[-1]
            Y = np.transpose(Y, tuple(dim))

    Out = np.atleast_1d(np.matmul(X, Y))
    return Out

class TestMatMulV2VectorXVectorOneDNNOp(OpTest):
    def config(self):
        self.x_shape = (100,)
        self.y_shape = (100,)
        self.trans_x = False
        self.trans_y = False
        self._cpu_only = True
        self.use_mkldnn = True

    def set_inputs(self, x, y):
        self.inputs = {'X': x, 'Y': y}

    def set_dtype_attr(self):
        self.attrs['mkldnn_data_type'] = "float32"

    def setUp(self):
        self.config()
        self.op_type = "matmul_v2"
        x = np.random.random(self.x_shape).astype("float32")
        y = np.random.random(self.y_shape).astype("float32")
        # -0.1 ~ 0.1
        x = -0.1 + 0.2 * x
        y = -0.1 + 0.2 * y
        result = reference_matmul(x, y, self.trans_x, self.trans_y).astype(
            "float32"
        )

        self.set_inputs(x, y)
        self.attrs = {
            'trans_x': self.trans_x,
            'trans_y': self.trans_y,
            'use_mkldnn': True,
        }
        self.set_dtype_attr()
        self.outputs = {'Out': result}

    def test_check_output(self):
        self.check_output()

    def test_check_grad(self):
        self.check_grad(['X', 'Y'], 'Out')

class TestMatMulV2VectorXMatrixTransposeYOneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (100,)
        self.y_shape = (1, 3, 2, 100)
        self.trans_x = False
        self.trans_y = True

class TestMatMulV2VectorXMatrixOneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (100,)
        self.y_shape = (1, 1, 100, 2)
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2MatrixXVectorTransposeXOneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (1, 1, 100, 1)
        self.y_shape = (100,)
        self.trans_x = True
        self.trans_y = False

class TestMatMulV2MatrixXVectorOneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (1, 2, 1, 100)
        self.y_shape = (100,)
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2MatrixXMatrixOneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (1, 1, 2, 100)
        self.y_shape = (1, 1, 100, 1)
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2MatrixXMatrixTransposeYOneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (1, 1, 1, 100)
        self.y_shape = (2, 1, 2, 100)
        self.trans_x = False
        self.trans_y = True

class TestMatMulV2MatrixXMatrix2OneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (2, 1, 12, 9)
        self.y_shape = (1, 3, 9, 12)
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2MatrixXMatrix3OneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (2, 1, 2, 100)
        self.y_shape = (1, 1, 100, 2)
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2MatrixXMatrixTranposeXOneDNNOp2(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (2, 1, 4, 25)
        self.y_shape = (1, 1, 4, 25)
        self.trans_x = True
        self.trans_y = False

class TestMatMulV2MatrixXMatrixTranposeX2OneDNNOp3(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (2, 2, 7, 4)
        self.y_shape = (2, 2, 7, 5)
        self.trans_x = True
        self.trans_y = False

class TestMatMulV2MatrixXMatrixTransposeX3OneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (3, 1, 6, 7)
        self.y_shape = (1, 2, 6, 9)
        self.trans_x = True
        self.trans_y = False

class TestMatMulV2MatrixXMatrix4OneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (3, 1, 6, 6)
        self.y_shape = (1, 2, 6, 9)
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2VectorXMatrix5DOneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = 100
        self.y_shape = (1, 2, 2, 100, 2)
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2Matrix3DXVectorOneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (2, 1, 100)
        self.y_shape = 100
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2MatrixXMatrixTransposeXTransposeYOneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (3, 1, 10, 8)
        self.y_shape = (1, 2, 9, 10)
        self.trans_x = True
        self.trans_y = True

class TestMatMulV2MatrixXMatrixTransposeY2OneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (3, 1, 10, 10)
        self.y_shape = (1, 2, 9, 10)
        self.trans_x = False
        self.trans_y = True

class TestMatMulV2MatrixXMatrix5DTranposeYOneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (1, 3, 1, 10, 10)
        self.y_shape = (3, 1, 2, 9, 10)
        self.trans_x = False
        self.trans_y = True

class TestMatMulV2MatrixXMatrix6Dx2DOneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (1, 1, 2, 1, 8, 9)
        self.y_shape = (9, 12)
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2MatrixXMatrix2Dx5DOneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (20, 5)
        self.y_shape = (1, 2, 1, 5, 11)
        self.trans_x = False
        self.trans_y = False

class TestMatMulV2MatrixXMatrix4Dx3DTransposeXOneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (5, 4, 15, 10)
        self.y_shape = (1, 15, 20)
        self.trans_x = True
        self.trans_y = False

class TestMatMulV2MatrixXMatrix3Dx4DTransposeYOneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (2, 10, 15)
        self.y_shape = (4, 2, 20, 15)
        self.trans_x = False
        self.trans_y = True

class TestMatMulV2MatrixXMatrix5Dx3DTransposeXTransposeYOneDNNOp(
    TestMatMulV2VectorXVectorOneDNNOp
):
    def config(self):
        self.x_shape = (4, 3, 2, 15, 10)
        self.y_shape = (1, 20, 15)
        self.trans_x = True
        self.trans_y = True

class TestMatMulV2MatrixXMatrix3Dx4DOneDNNOp(TestMatMulV2VectorXVectorOneDNNOp):
    def config(self):
        self.x_shape = (1, 1, 32, 16)
        self.y_shape = (16, 16, 16)
        self.trans_x = False
        self.trans_y = False

#   BF16 TESTS
def create_bf16_test_class(parent):
    @OpTestTool.skip_if_not_cpu_bf16()
    class TestMatMulV2Bf16OneDNNOp(parent):
        def set_inputs(self, x, y):
            self.inputs = {
                'X': convert_float_to_uint16(x),
                'Y': convert_float_to_uint16(y),
            }
            self.x_fp32 = x
            self.y_fp32 = y

        def set_dtype_attr(self):
            self.attrs['mkldnn_data_type'] = "bfloat16"

        def test_check_output(self):
            self.check_output_with_place(core.CPUPlace())

        def test_check_grad(self):
            self.calculate_grads()
            self.check_grad_with_place(
                core.CPUPlace(),
                ["X", "Y"],
                "Out",
                user_defined_grads=[self.dx, self.dy],
                user_defined_grad_outputs=[convert_float_to_uint16(self.dout)],
            )

        def matmul_grad(self, x, transpose_x, y, transpose_y):
            x = (
                np.transpose(x, self.shape_transpose_axes[x.ndim])
                if transpose_x
                else x
            )
            y = (
                np.transpose(y, self.shape_transpose_axes[y.ndim])
                if transpose_y
                else y
            )

            return np.matmul(x, y)

        def calculate_grads(self):
            self.shape_transpose_axes = {
                2: [1, 0],
                3: [0, 2, 1],
                4: [0, 1, 3, 2],
                5: [0, 1, 2, 4, 3],
                6: [0, 1, 2, 3, 5, 4],
            }

            # expand vector so it will be a valid matrix for multiplication
            if self.x_fp32.ndim == 1:
                self.x_fp32 = np.expand_dims(self.x_fp32, axis=0)
            if self.y_fp32.ndim == 1:
                self.y_fp32 = np.expand_dims(self.y_fp32, axis=1)

            x_transpose_axes = self.shape_transpose_axes[self.x_fp32.ndim]
            y_transpose_axes = self.shape_transpose_axes[self.y_fp32.ndim]

            x = (
                np.transpose(self.x_fp32, x_transpose_axes)
                if self.attrs['trans_x'] is True
                else self.x_fp32
            )
            y = (
                np.transpose(self.y_fp32, y_transpose_axes)
                if self.attrs['trans_y'] is True
                else self.y_fp32
            )

            dout = np.matmul(x, y)

            x_shape = x.shape
            y_shape = y.shape

            if x.ndim <= 2 or y.ndim <= 2:
                is_broadcast = False
            elif x.ndim != y.ndim:
                is_broadcast = True
            else:
                is_broadcast = x.shape[0:-2] != y.shape[0:-2]

            if self.attrs['trans_x'] is True and self.attrs['trans_y'] is True:
                self.dx = self.matmul_grad(self.y_fp32, True, dout, True)
                self.dy = self.matmul_grad(dout, True, self.x_fp32, True)
            elif (
                self.attrs['trans_x'] is True and self.attrs['trans_y'] is False
            ):
                self.dx = self.matmul_grad(self.y_fp32, False, dout, True)
                self.dy = self.matmul_grad(self.x_fp32, False, dout, False)
            elif (
                self.attrs['trans_x'] is False and self.attrs['trans_y'] is True
            ):
                self.dx = self.matmul_grad(dout, False, self.y_fp32, False)
                self.dy = self.matmul_grad(dout, True, self.x_fp32, False)
            else:
                self.dx = self.matmul_grad(dout, False, self.y_fp32, True)
                self.dy = self.matmul_grad(self.x_fp32, True, dout, False)

            if is_broadcast:
                x_reduce_axis = []
                y_reduce_axis = []
                for index, (first, second) in enumerate(
                    zip(x_shape[0:-2], self.dx.shape[0:-2])
                ):
                    if first != second:
                        x_reduce_axis.append(index)

                for index, (first, second) in enumerate(
                    zip(y_shape[0:-2], self.dy.shape[0:-2])
                ):
                    if first != second:
                        y_reduce_axis.append(index)

                if x_reduce_axis:
                    self.dx = self.dx.sum(
                        axis=tuple(x_reduce_axis), keepdims=True
                    )
                if y_reduce_axis:
                    self.dy = self.dy.sum(
                        axis=tuple(y_reduce_axis), keepdims=True
                    )

            # after multiplying with vector one dimension is deleted from tensor
            if len(x_shape) == 2 and x_shape[0] == 1:
                dout = dout.sum(axis=-2)
            if len(y_shape) == 2 and y_shape[1] == 1:
                dout = dout.sum(axis=-1)

            self.dout = dout

    cls_name = "{0}_{1}".format(parent.__name__, "BF16")
    TestMatMulV2Bf16OneDNNOp.__name__ = cls_name
    globals()[cls_name] = TestMatMulV2Bf16OneDNNOp

create_bf16_test_class(TestMatMulV2VectorXMatrixTransposeYOneDNNOp)
create_bf16_test_class(TestMatMulV2VectorXMatrixOneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXVectorTransposeXOneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXVectorOneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrixOneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrixTransposeYOneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrix2OneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrix3OneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrixTranposeXOneDNNOp2)
create_bf16_test_class(TestMatMulV2MatrixXMatrixTranposeX2OneDNNOp3)
create_bf16_test_class(TestMatMulV2MatrixXMatrixTransposeX3OneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrix4OneDNNOp)
create_bf16_test_class(TestMatMulV2VectorXMatrix5DOneDNNOp)
create_bf16_test_class(TestMatMulV2Matrix3DXVectorOneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrixTransposeXTransposeYOneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrixTransposeY2OneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrix5DTranposeYOneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrix6Dx2DOneDNNOp)
create_bf16_test_class(TestMatMulV2MatrixXMatrix2Dx5DOneDNNOp)

class TestMatMulV2OpTransposeReshapeEmptyFloat(
    TestMatMulOpTransposeReshapeEmptyFloat
):
    def set_op_type(self):
        self.op_type = "matmul_v2"

class TestMatMulV2OpTransposeReshapeBasicFloat(
    TestMatMulOpTransposeReshapeBasicFloat
):
    def set_op_type(self):
        self.op_type = "matmul_v2"

class TestMatMulV2OpTransposeReshapeOtherDimFloat(
    TestMatMulOpTransposeReshapeOtherDimFloat
):
    def set_op_type(self):
        self.op_type = "matmul_v2"

class TestMatMulV2OpReshapeTranspose(TestReshapeTransposeMatMulOp):
    def set_op_type_and_transpose_y_name(self):
        self.op_type = "matmul_v2"
        self.transpose_y_name = "trans_y"

class TestMatMulV2OpReshapeTranspose4DXFloat(
    TestReshapeTransposeMatMulOp4DXFloat
):
    def set_op_type_and_transpose_y_name(self):
        self.op_type = "matmul_v2"
        self.transpose_y_name = "trans_y"

class TestMatMulV2OpReshapeTranspose4DYFloat(
    TestReshapeTransposeMatMulOp4DYFloat
):
    def set_op_type_and_transpose_y_name(self):
        self.op_type = "matmul_v2"
        self.transpose_y_name = "trans_y"

class TestMatMulV2OpReshapeTranspose4DXYFloat(
    TestReshapeTransposeMatMulOp4DXYFloat
):
    def set_op_type_and_transpose_y_name(self):
        self.op_type = "matmul_v2"
        self.transpose_y_name = "trans_y"

class TestMatMulV2OpReshapeTranspose2DXFloat(
    TestReshapeTransposeMatMulOp2DXFloat
):
    def set_op_type_and_transpose_y_name(self):
        self.op_type = "matmul_v2"
        self.transpose_y_name = "trans_y"

class TestMatMulV2OpReshapeTranspose2DYFloat(
    TestReshapeTransposeMatMulOp2DYFloat
):
    def set_op_type_and_transpose_y_name(self):
        self.op_type = "matmul_v2"
        self.transpose_y_name = "trans_y"

class TestMatMulV2OpReshapeTranspose3DXFloat(
    TestReshapeTransposeMatMulOp3DXFloat
):
    def set_op_type_and_transpose_y_name(self):
        self.op_type = "matmul_v2"
        self.transpose_y_name = "trans_y"

class TestMatMulV2OpReshapeTranspose3DYFloat(
    TestReshapeTransposeMatMulOp3DYFloat
):
    def set_op_type_and_transpose_y_name(self):
        self.op_type = "matmul_v2"
        self.transpose_y_name = "trans_y"

if __name__ == "__main__":
    paddle.enable_static()
    unittest.main()


text:
function playTone (note, octave) {
  tones.play(note, octave);
}

function playOne (element, delay, i) {
  function play () {
    element.className = element.className + " auto-playing";
    element.onmouseover();
    setTimeout(function () {
      element.className = element.className.replace(" auto-playing", "");
    }, delay);
  }

  setTimeout(play, delay * i);
}

function autoPlayAll (delay) {
  var elements = document.querySelectorAll('div');

  function playAll () {
    for (var i = 0; i < elements.length; i++) {
      playOne(elements[i], delay, i);
    }
  }

  playAll();
  setInterval(playAll, delay * elements.length);
}

/**
 * To cancel a timeout, you execute the `clearTimeout` function with the
 * id (which is a number) of the timeout.
 * When you create a timeout (including intervals, which are a special
 * kind of timeout), it returns its id, which is always one number higher
 * than the previous one, starting with the number 1.
 * Therefore, if you want to clear all timeouts, you can create a new
 * timeout, capture its id, and then clear all the timeouts starting from
 * 1 up to and including the timeout you created. This will also "clear"
 * timeouts that are already over, which is does not throw an error.
 */
function clearAllTimeouts () {
  var nextTimeout = setTimeout(function(){}, 0);
  for (var i = 1; i <= nextTimeout; i++) {
    clearTimeout(i);
  }
}

function resetClassNames () {
  var elements = document.querySelectorAll('.auto-playing');
  for (var i = 0; i < elements.length; i++) {
    elements[i].className = elements[i].className.replace(/ auto-playing/g, "");
  }
}

function stopAutoPlayback () {
  clearAllTimeouts();
  resetClassNames();
}

document.addEventListener("keydown", function (e) {
  if (e.code === "Space") {
    autoPlayAll(60 * 1000 / bpm);
  }

  if (e.code === "Escape") {
    stopAutoPlayback();
  }
});

/* Special features */

// bmp means "beats per minute".
// Sets the tempo of the autoplay.
var bpm = 300;

// The "type" determines the shape of the sound wave.
// The available types are: "sine", "square", "sawtooth", "triangle"
tones.type = "sine"

// The "attack" determines how intensely the sound starts.
// Try other numbers to see how it smooths out the tone.
tones.attack = 1

// The "release" determines how quickly the sound fades out.
// Try other numbers to see how it creates clipped or echoey sounds.
tones.release = 100

// Takes an integer and returns a note in Hz.
// Integers 0 though 7 are the notes on the C Major scale.
function noteFromNumber (i) {
  var centerOctave = 4;
  var notes = ["c", "d", "e", "f", "g", "a", "b"];
  var notesPerOctave = notes.length;

  var j = i + (notesPerOctave * centerOctave);
  var octave = Math.floor(j / notesPerOctave);
  var note = notes[j % notesPerOctave];

  // Only octaves 0 through 9 are supported
  if (octave < 0 || octave > 9) {
    throw "The number " + i + " is outside of the supported range of the noteFromNumber function";
  } else {
    return tones.map[octave][note];
  }
}

// Returns a random shape: "triangle", "circle", "square", "diamond", "star"
function randomShape () {
  var shapes = ["triangle", "circle", "square", "diamond", "star"];
  var i = Math.floor(Math.random() * shapes.length);
  return shapes[i];
}

// Returns a random color: "red", "yellow", "blue", "orange", "green", "purple", "pink", "black"
function randomColor () {
  var colors = ["red", "yellow", "blue", "orange", "green", "purple", "pink", "black"];
  var i = Math.floor(Math.random() * colors.length);
  return colors[i];
}

// Returns a random note from the audible range
function randomNote () {
  var audibleOctives = tones.map.slice(2, 8);
  var octaves = audibleOctives.map(function (octave) {
    return Object.keys(octave).map(function (key) {
      return octave[key];
    });
  });
  var allNotes = octaves.reduce(function (notes, notesInOctave) {
    return notes.concat(notesInOctave);
  }, []);

  return allNotes[Math.floor(Math.random() * allNotes.length)];
}

function triggerMouseOver (e) {
  if (e.target.onmouseover) {
    e.target.onmouseover();
  }
}

window.addEventListener("touchstart", function (e) {
  if (e.touches.length === 1) {
    triggerMouseOver(e)
  }

  if (e.touches.length === 2) {
    autoPlayAll(60 * 1000 / bpm);
  }

  if (e.touches.length === 3) {
    stopAutoPlayback();
  }
}, false);

window.addEventListener("load", function () {

    var instructions = document.createElement("section");
    instructions.className = "instructions";
    instructions.innerHTML = "
Tap the screen with two fingers to start playing sound.

Tap with three fingers to stop.</>"

    instructions.ontouchstart = function () {
      playTone("c");
      document.body.removeChild(instructions);
    }
    document.body.appendChild(instructions)

}, false);


text:
package com.etsy.conjecture.data;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;

import com.google.gson.Gson;

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

import org.junit.Test;

public class LazyVectorTest {

    final double eps = 0.000001;

    // Update function to use for testing.
    // Decay the parameters over time.
    final static LazyVector.UpdateFunction uf = new LazyVector.UpdateFunction() {

        private static final long serialVersionUID = 1019666879466468375L;
        public double lazyUpdate(String k, double p, long a, long b) {
            return p * Math.pow(0.9, b - a);
        }
    };

    // Build an SKV in a way which exercises a bunch of different code.
    public LazyVector buildLV() {
        LazyVector lv = new LazyVector(uf);
        lv.setCoordinate("foo", 1.0);
        lv.addToCoordinate("bar", -2.0);
        lv.addToCoordinate("baz", 0.0);
        lv.setCoordinate("dave", 5.0);
        lv.deleteCoordinate("dave");
        return lv;
    }

    /**
     * Basic testing of coordinate getting and setting.
     */
    @Test
    public void testCoordinates() {
        LazyVector lv = buildLV();
        assertEquals(2, lv.size());
        assertEquals(1.0, lv.getCoordinate("foo"), eps);
        assertEquals(-2.0, lv.getCoordinate("bar"), eps);
        assertEquals(0.0, lv.getCoordinate("baz"), eps);
        assertEquals(0.0, lv.getCoordinate("dave"), eps);
        assertEquals(0.0, lv.getCoordinate("test"), eps);
    }

    /**
     * Basic testing of lazy updating.
     */
    @Test
    public void testCoordinatesLazy() {
        LazyVector lv = buildLV();
        lv.incrementIteration();
        assertEquals(2, lv.size());
        assertEquals(0.9, lv.getCoordinate("foo"), eps);
        assertEquals(-1.8, lv.getCoordinate("bar"), eps);
        assertEquals(0.0, lv.getCoordinate("baz"), eps);
        assertEquals(0.0, lv.getCoordinate("dave"), eps);
        assertEquals(0.0, lv.getCoordinate("test"), eps);
        lv.setCoordinate("bar", 2.0);
        lv.incrementIteration();
        assertEquals(2, lv.size());
        assertEquals(0.81, lv.getCoordinate("foo"), eps);
        assertEquals(1.8, lv.getCoordinate("bar"), eps);
    }

    /**
     * Test addScaled.
     */
    @Test
    public void testAddScaledToSKV() {
        LazyVector lv = buildLV();
        StringKeyedVector accum = new StringKeyedVector();
        accum.addScaled(lv, 2.0);
        assertEquals(2, accum.size());
        assertEquals(2.0, accum.getCoordinate("foo"), eps);
        assertEquals(-4.0, accum.getCoordinate("bar"), eps);
        lv.incrementIteration();
        accum.addScaled(lv, -2.0);
        assertEquals(2, accum.size());
        assertEquals(0.2, accum.getCoordinate("foo"), eps);
        assertEquals(-0.4, accum.getCoordinate("bar"), eps);
    }

    /**
     * Test addScaled.
     */
    @Test
    public void testAddScaledToLV() {
        LazyVector lv = buildLV();
        LazyVector accum = new LazyVector(uf);
        accum.setCoordinate("foo", 10.0);
        accum.incrementIteration();
        accum.incrementIteration();
        accum.incrementIteration(); // foo is now 7.29
        accum.addScaled(lv, 2.0);
        assertEquals(2, accum.size());
        assertEquals(9.29, accum.getCoordinate("foo"), eps);
        assertEquals(-4.0, accum.getCoordinate("bar"), eps);
        lv.incrementIteration(); // foo is now 0.9
        accum.incrementIteration(); // foo is now 8.361
        accum.addScaled(lv, -2.0);
        assertEquals(1, accum.size());
        assertEquals(6.561, accum.getCoordinate("foo"), eps);
    }

    /**
     * Test addScaled.
     */
    @Test
    public void testAddScaledToSelf() {
        LazyVector lv = buildLV();
        lv.incrementIteration();
        lv.incrementIteration();
        lv.addScaled(lv, 1.0);
        assertEquals(2, lv.size());
        assertEquals(1.0 * 0.81 * 2, lv.getCoordinate("foo"), eps);
        assertEquals(-2.0 * 0.81 * 2, lv.getCoordinate("bar"), eps);
    }

    /**
     * Test addScaled.
     */
    @Test
    public void testAddScaledSKVToLV() {
        LazyVector accum = new LazyVector(uf);
        StringKeyedVector skv = new StringKeyedVector();
        skv.setCoordinate("foo", 1.0);
        skv.setCoordinate("bar", 5.0);
        accum.addScaled(skv, 2.0);
        assertEquals(2, accum.size());
        assertEquals(2.0, accum.getCoordinate("foo"), eps);
        assertEquals(10.0, accum.getCoordinate("bar"), eps);
        accum.incrementIteration();
        accum.incrementIteration(); // foo: 1.62, bar: 8.10
        accum.addScaled(skv, -1.0);
        assertEquals(2, accum.size());
        assertEquals(0.62, accum.getCoordinate("foo"), eps);
        assertEquals(3.10, accum.getCoordinate("bar"), eps);
    }

    /**
     * Test the dot product.
     */
    @Test
    public void testDotProduct() {
        LazyVector skv = buildLV();
        StringKeyedVector skv2 = new StringKeyedVector(skv);
        assertEquals(5.0, skv.dot(skv), eps);
        skv.incrementIteration();
        assertEquals(5.0 * 0.81, skv.dot(skv), eps);
        skv2.addToCoordinate("baz", -10.0);
        assertEquals(5.0 * 0.9, skv.dot(skv2), eps);
    }

    /**
     * Test freezing the keys.
     */
    @Test
    public void testFreezing() {
        LazyVector skv = buildLV();
        skv.setFreezeKeySet(true);
        skv.addToCoordinate("fake", 1.0);
        assertEquals(2, skv.size());
        skv.setCoordinate("fake2", 2.0);
        assertEquals(2, skv.size());
        skv.setFreezeKeySet(false);
        skv.setCoordinate("fake2", 2.0);
        assertEquals(3, skv.size());
    }

    /**
     * Test java serialization.
     */
    @Test
    public void testJavaSerialization() throws Exception {
        LazyVector skv = buildLV();
        skv.incrementIteration();
        // Serialize to a byte array in ram.
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(skv);
        oos.flush();
        // Deserialize.
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        LazyVector des = (LazyVector)ois.readObject();
        assertFalse(des.getFreezeKeySet());
        assertEquals(2, des.size());
        assertEquals(0.9, des.getCoordinate("foo"), eps);
        assertEquals(-1.8, des.getCoordinate("bar"), eps);
        des.incrementIteration();
        assertEquals(2, des.size());
        assertEquals(0.81, des.getCoordinate("foo"), eps);
        assertEquals(-1.62, des.getCoordinate("bar"), eps);
    }

    /**
     * Test kryo serialization.
     */
    @Test
    public void testKryoSerialization() throws Exception {
        LazyVector skv = buildLV();
        skv.incrementIteration();
        // Serialize to a byte array in ram.
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        Output ko = new Output(bos);
        Kryo kry = new Kryo();
        kry.writeObject(ko, skv);
        ko.flush();
        // Deserialize.
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        Input ki = new Input(bis);
        LazyVector des = (LazyVector)kry.readObject(ki, LazyVector.class);
        assertFalse(des.getFreezeKeySet());
        assertEquals(2, des.size());
        assertEquals(0.9, des.getCoordinate("foo"), eps);
        assertEquals(-1.8, des.getCoordinate("bar"), eps);
        des.incrementIteration();
        assertEquals(2, des.size());
        assertEquals(0.81, des.getCoordinate("foo"), eps);
        assertEquals(-1.62, des.getCoordinate("bar"), eps);
    }

    /**
     * Make sure Gson serializes this thing properly.
     */
    @Test
    public void testGson() {
        Gson gson = new Gson();
        String json = gson.toJson(buildLV());
        String vector1 = "\"vector\":{\"foo\":1.0,\"bar\":-2.0}";
        String vector2 = "\"vector\":{\"bar\":-2.0,\"foo\":1.0}";
        String fks = "\"freezeKeySet\":false";
        assertTrue(json.contains(vector1) || json.contains(vector2));
        assertTrue(json.contains(fks));
        assertFalse(json.contains("iterations"));
    }

}


text:
package com.datastax.driver.stress;

import java.nio.ByteBuffer;
import java.util.Random;

import com.datastax.driver.core.*;
import com.datastax.driver.core.exceptions.*;
import com.datastax.driver.core.utils.Bytes;

import joptsimple.OptionParser;
import joptsimple.OptionSet;

public class Generators {
    private static ThreadLocal<Random> random = new ThreadLocal<Random>() {
        protected Random initialValue() {
            return new Random();
        }
    };

    private static ByteBuffer makeValue(final int valueSize) {
        byte[] value = new byte[valueSize];
        random.get().nextBytes(value);
        return ByteBuffer.wrap(value);
    }

    private static abstract class AbstractGenerator extends QueryGenerator {
        protected int iteration;

        protected AbstractGenerator(int iterations) {
            super(iterations);
        }

        @Override
        public int currentIteration() {
            return iteration;
        }

        @Override
        public boolean hasNext() {
            return iterations == -1 || iteration < iterations;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

    public static final QueryGenerator.Builder INSERTER = new QueryGenerator.Builder() {

        public String name() {
            return "insert";
        }

        public OptionParser addOptions(OptionParser parser) {
            String msg = "Simple insertion of CQL3 rows (using prepared statements unless the --no-prepare option is used). "
                       + "The inserted rows have a fixed set of columns but no clustering columns.";
            parser.formatHelpWith(Stress.Help.formatFor(name(), msg));

            parser.accepts("no-prepare", "Do no use prepared statement");
            parser.accepts("columns-per-row", "Number of columns per CQL3 row").withRequiredArg().ofType(Integer.class).defaultsTo(5);
            parser.accepts("value-size", "The size in bytes for column values").withRequiredArg().ofType(Integer.class).defaultsTo(34);
            parser.accepts("with-compact-storage", "Use COMPACT STORAGE on the table used");
            return parser;
        }

        public void prepare(OptionSet options, Session session) {

            try {
                session.execute("DROP KEYSPACE stress;");
            } catch (QueryValidationException e) { /* Fine, ignore */ }

            session.execute("CREATE KEYSPACE stress WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 }");

            session.execute("USE stress");

            StringBuilder sb = new StringBuilder();
            sb.append("CREATE TABLE standard1 (key bigint PRIMARY KEY");
            for (int i = 0; i < (Integer)options.valueOf("columns-per-row"); ++i)
                sb.append(", C").append(i).append(" blob");
            sb.append(')');

            if (options.has("with-compact-storage"))
                sb.append(" WITH COMPACT STORAGE");

            session.execute(sb.toString());
        }

        public QueryGenerator create(int id, int iterations, OptionSet options, Session session) {

            return options.has("no-prepare")
                 ? createRegular(id, iterations, options)
                 : createPrepared(id, iterations, options, session);
        }

        public QueryGenerator createRegular(int id, int iterations, OptionSet options) {
            final int valueSize = (Integer)options.valueOf("value-size");
            final int columnsPerRow = (Integer)options.valueOf("columns-per-row");
            final long prefix = (long) id << 32;

            return new AbstractGenerator(iterations) {
                @Override
                public QueryGenerator.Request next() {
                    StringBuilder sb = new StringBuilder();
                    sb.append("UPDATE standard1 SET ");
                    for (int i = 0; i < columnsPerRow; ++i) {
                        if (i > 0) sb.append(", ");
                        sb.append('C').append(i).append("='").append(Bytes.toHexString(makeValue(valueSize))).append('\'');
                    }
                    sb.append(" WHERE key = ").append(prefix | iteration);
                    ++iteration;
                    return new QueryGenerator.Request.SimpleQuery(new SimpleStatement(sb.toString()));
                }
            };
        }

        public QueryGenerator createPrepared(int id, int iterations, OptionSet options, Session session) {
            final int valueSize = (Integer)options.valueOf("value-size");
            final int columnsPerRow = (Integer)options.valueOf("columns-per-row");
            final long prefix = (long) id << 32;

            StringBuilder sb = new StringBuilder();
            sb.append("UPDATE standard1 SET ");
            for (int i = 0; i < columnsPerRow; ++i) {
                if (i > 0) sb.append(", ");
                sb.append('C').append(i).append("=?");
            }
            sb.append(" WHERE key = ?");

            final PreparedStatement stmt = session.prepare(sb.toString());

            return new AbstractGenerator(iterations) {
                @Override
                public QueryGenerator.Request next() {
                    BoundStatement b = stmt.bind();
                    b.setLong("key", prefix | iteration);
                    for (int i = 0; i < columnsPerRow; ++i)
                        b.setBytes("c" + i, makeValue(valueSize));
                    ++iteration;
                    return new QueryGenerator.Request.PreparedQuery(b);
                }
            };
        }
    };

    public static final QueryGenerator.Builder READER = new QueryGenerator.Builder() {

        public String name() {
            return "read";
        }

        public OptionParser addOptions(OptionParser parser) {
            String msg = "Read the rows inserted with the insert generator. Use prepared statements unless the --no-prepare option is used.";
            parser.formatHelpWith(Stress.Help.formatFor(name(), msg));

            parser.accepts("no-prepare", "Do no use prepared statement");
            return parser;
        }

        public void prepare(OptionSet options, Session session) {
            KeyspaceMetadata ks = session.getCluster().getMetadata().getKeyspace("stress");
            if (ks == null || ks.getTable("standard1") == null) {
                System.err.println("There is nothing to reads, please run insert/insert_prepared first.");
                System.exit(1);
            }

            session.execute("USE stress");
        }

        public QueryGenerator create(int id, int iterations, OptionSet options, Session session) {
            return options.has("no-prepare")
                 ? createRegular(id, iterations)
                 : createPrepared(id, iterations, session);
        }

        public QueryGenerator createRegular(long id, int iterations) {
            final long prefix = (long) id << 32;
            return new AbstractGenerator(iterations) {
                @Override
                public QueryGenerator.Request next() {
                    StringBuilder sb = new StringBuilder();
                    sb.append("SELECT * FROM standard1 WHERE key = ").append(prefix | iteration);
                    ++iteration;
                    return new QueryGenerator.Request.SimpleQuery(new SimpleStatement(sb.toString()));
                }
            };
        }

        public QueryGenerator createPrepared(long id, int iterations, Session session) {
            final long prefix = (long) id << 32;
            final PreparedStatement stmt = session.prepare("SELECT * FROM standard1 WHERE key = ?");

            return new AbstractGenerator(iterations) {
                @Override
                public QueryGenerator.Request next() {
                    BoundStatement bs = stmt.bind();
                    bs.setLong("key", prefix | iteration);
                    ++iteration;
                    return new QueryGenerator.Request.PreparedQuery(bs);
                }
            };
        }
    };
}


text:
.class public Lorg/achartengine/model/MultipleCategorySeries;
.super Ljava/lang/Object;

# interfaces
.implements Ljava/io/Serializable;

# instance fields
.field private a:Ljava/lang/String;

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

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

.field private d:Ljava/util/List;
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "Ljava/util/List",
            "<[D>;"
        }
    .end annotation
.end field

# direct methods
.method public constructor <init>(Ljava/lang/String;)V
    .locals 1

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

    new-instance v0, Ljava/util/ArrayList;

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

    iput-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->b:Ljava/util/List;

    new-instance v0, Ljava/util/ArrayList;

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

    iput-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->c:Ljava/util/List;

    new-instance v0, Ljava/util/ArrayList;

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

    iput-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->d:Ljava/util/List;

    iput-object p1, p0, Lorg/achartengine/model/MultipleCategorySeries;->a:Ljava/lang/String;

    return-void
.end method

# virtual methods
.method public add(Ljava/lang/String;[Ljava/lang/String;[D)V
    .locals 1

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->b:Ljava/util/List;

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

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->c:Ljava/util/List;

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

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->d:Ljava/util/List;

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

    return-void
.end method

.method public add([Ljava/lang/String;[D)V
    .locals 2

    new-instance v0, Ljava/lang/StringBuilder;

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

    iget-object v1, p0, Lorg/achartengine/model/MultipleCategorySeries;->b:Ljava/util/List;

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

    move-result v1

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

    move-result-object v0

    const-string v1, ""

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

    move-result-object v0

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

    move-result-object v0

    invoke-virtual {p0, v0, p1, p2}, Lorg/achartengine/model/MultipleCategorySeries;->add(Ljava/lang/String;[Ljava/lang/String;[D)V

    return-void
.end method

.method public clear()V
    .locals 1

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->b:Ljava/util/List;

    invoke-interface {v0}, Ljava/util/List;->clear()V

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->c:Ljava/util/List;

    invoke-interface {v0}, Ljava/util/List;->clear()V

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->d:Ljava/util/List;

    invoke-interface {v0}, Ljava/util/List;->clear()V

    return-void
.end method

.method public getCategoriesCount()I
    .locals 1

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->b:Ljava/util/List;

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

    move-result v0

    return v0
.end method

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

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->b:Ljava/util/List;

    invoke-interface {v0, p1}, Ljava/util/List;->get(I)Ljava/lang/Object;

    move-result-object v0

    check-cast v0, Ljava/lang/String;

    return-object v0
.end method

.method public getItemCount(I)I
    .locals 1

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->d:Ljava/util/List;

    invoke-interface {v0, p1}, Ljava/util/List;->get(I)Ljava/lang/Object;

    move-result-object v0

    check-cast v0, [D

    array-length v0, v0

    return v0
.end method

.method public getTitles(I)[Ljava/lang/String;
    .locals 1

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->c:Ljava/util/List;

    invoke-interface {v0, p1}, Ljava/util/List;->get(I)Ljava/lang/Object;

    move-result-object v0

    check-cast v0, [Ljava/lang/String;

    return-object v0
.end method

.method public getValues(I)[D
    .locals 1

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->d:Ljava/util/List;

    invoke-interface {v0, p1}, Ljava/util/List;->get(I)Ljava/lang/Object;

    move-result-object v0

    check-cast v0, [D

    return-object v0
.end method

.method public remove(I)V
    .locals 1

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->b:Ljava/util/List;

    invoke-interface {v0, p1}, Ljava/util/List;->remove(I)Ljava/lang/Object;

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->c:Ljava/util/List;

    invoke-interface {v0, p1}, Ljava/util/List;->remove(I)Ljava/lang/Object;

    iget-object v0, p0, Lorg/achartengine/model/MultipleCategorySeries;->d:Ljava/util/List;

    invoke-interface {v0, p1}, Ljava/util/List;->remove(I)Ljava/lang/Object;

    return-void
.end method

.method public toXYSeries()Lorg/achartengine/model/XYSeries;
    .locals 2

    new-instance v0, Lorg/achartengine/model/XYSeries;

    iget-object v1, p0, Lorg/achartengine/model/MultipleCategorySeries;->a:Ljava/lang/String;

    invoke-direct {v0, v1}, Lorg/achartengine/model/XYSeries;-><init>(Ljava/lang/String;)V

    return-object v0
.end method


text:
package com.weixin.vo;

import java.io.Serializable;
import java.util.List;

/**
 * @author jay
 * @since 2016年6月13日
 */
public class NewsVo implements Serializable {

	private static final long serialVersionUID = 1L;
	private List<WxArticleVo> articles;

	public List<WxArticleVo> getArticles() {
		return articles;
	}

	public void setArticles(List<WxArticleVo> articles) {
		this.articles = articles;
	}

}


text:
package types

type IType uint8

const (
	EmptyInterface    IType = 1 << iota // ref as empty
	AnonInterface                       // ref as anon
	ErrorInterface                      // ref as error
	NamedInterface                      // ref as named
	NamedStdInterface                   // ref as named stdlib
)


text:
class Nitroshare < Cask
  version '0.2'
  sha256 '9f208d4b86ca13c4136265fa4a4693c7ef9ba9f0d6a0a84966cfd5f9934abe12'

  url "https://launchpad.net/nitroshare/#{version}/#{version}/+download/nitroshare_#{version}.app.dmg"
  homepage 'https://quickmediasolutions.com/apps/14/nitroshare'
  license :unknown

  app 'NitroShare.app'
end


text:
module Passman
  require_relative 'passman/app.rb'
end


text:
require "webmock/rspec"

require_relative "factory"

module ClearElection
  module Rspec

    def self.setup(agent: false)
      RSpec.configure do |config|
        config.include Helpers
        if agent
          config.before(:each) do
            setup_my_agent_uri
          end
        end
      end
    end

    module Helpers
      # creates a webmock stub request for an election_uri to return an election
      def stub_election_uri(election: nil, election_uri: nil, booth: nil, signin: nil, pollsOpen: nil, pollsClose: nil, valid: true)
        election_uri ||= ClearElection::Factory.election_uri
        if valid
          election ||= ClearElection::Factory.election(booth: booth, signin: signin, pollsOpen: pollsOpen, pollsClose: pollsClose)
          result = { body: JSON.generate(election.as_json) }
        else
          result = { status: 404 }
        end
        stub_request(:get, election_uri).to_return result
        election_uri
      end

      # creates a webmock stub for signin with an access token
      def stub_election_access_token(election_uri:, election: nil, accessToken: nil, demographic: nil, valid: true)
        accessToken ||= SecureRandom.hex(10)
        if valid
          result = { status: 200, body: JSON.generate(demographic: demographic) }
        else
          result = { status: 403 }
        end
        election ||= ClearElection.read(election_uri)
        stub_request(:post, election.signin.uri + "redeem").with(body: {election: election_uri, accessToken: accessToken}).to_return result
        accessToken
      end

      # For use in an agent: create a URI that will act in rspec as if
      # it's URI at which the app was called
      def setup_my_agent_uri
        host! URI(my_agent_uri).host
        allow_any_instance_of(ActionDispatch::Request).to receive(:original_url) { |request|
          request.base_url + URI(my_agent_uri).path + request.original_fullpath
        }
      end

      def my_agent_uri
        @my_agent_uri ||= ClearElection::Factory.agent_uri(Rails.root.basename)
      end

      shared_examples "api that verifies election state" do |state|
        describe "verifies election is #{state}" do

          oneDay = 60*60*24

          case state
          when :open
            it "rejects if polls have not opened" do
              Timecop.travel(election.pollsOpen - oneDay) do
                api_bound.call
                expect(response).to have_http_status 403
                expect(JSON.parse(response.body)["error"]).to match /open/i
              end
            end
            it "rejects if polls have closed" do
              Timecop.travel(election.pollsClose + oneDay) do
                api_bound.call
                expect(response).to have_http_status 403
                expect(JSON.parse(response.body)["error"]).to match /open/i
              end
            end

          when :closed
            it "rejects if polls have not closed" do
              Timecop.travel(election.pollsClose - oneDay) do
                api_bound.call
                expect(response).to have_http_status 403
                expect(JSON.parse(response.body)["error"]).to match /closed/i
              end
            end

          else
            raise "Unknown election verification state #{state.inspect}" unless state == :unopen
            it "rejects if polls have opened" do
              Timecop.travel(election.pollsOpen + oneDay) do
                api_bound.call
                expect(response).to have_http_status 403
                expect(JSON.parse(response.body)["error"]).to match /open/i
              end
            end
          end
        end
      end

      shared_examples "api that validates election URI" do |state: nil, agent: nil|

        describe "verifies election URI" do
          it "rejects invalid election URI" do
            apicall.call stub_election_uri(valid: false)
            expect(response).to have_http_status 422
            expect(JSON.parse(response.body)["error"]).to match /uri/i
          end

          it "rejects if I am not #{agent} agent" do
            apicall.call stub_election_uri() # not passing my_agent_uri
            expect(response).to have_http_status 422
            expect(JSON.parse(response.body)["error"]).to match /#{agent} agent/i
          end if agent
        end

        let(:election_uri) { stub_election_uri(agent ? { agent => my_agent_uri } : {}) }

        it_behaves_like "api that verifies election state", state do
          let(:election) { ClearElection.read(election_uri) }
          let(:api_bound) { -> { apicall.call election_uri } }
        end if state

      end
    end
  end
end


text:
function [file] = read_bti_ascii(filename);

% READ_BTI_ASCII reads general data from a BTI configuration file
%
% The file should be formatted like
%    Group:
%      item1 : value1a value1b value1c
%      item2 : value2a value2b value2c
%      item3 : value3a value3b value3c
%      item4 : value4a value4b value4c
%

% Copyright (C) 2004, Robert Oostenveld
%
% This file is part of FieldTrip, see http://www.ru.nl/neuroimaging/fieldtrip
% for the documentation and details.
%
%    FieldTrip is free software: you can redistribute it and/or modify
%    it under the terms of the GNU General Public License as published by
%    the Free Software Foundation, either version 3 of the License, or
%    (at your option) any later version.
%
%    FieldTrip is distributed in the hope that it will be useful,
%    but WITHOUT ANY WARRANTY; without even the implied warranty of
%    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
%    GNU General Public License for more details.
%
%    You should have received a copy of the GNU General Public License
%    along with FieldTrip. If not, see <http://www.gnu.org/licenses/>.
%
% $Id: read_bti_ascii.m 945 2010-04-21 17:41:20Z roboos $

fid = fopen(filename, 'r');
if fid==-1
  error(sprintf('could not open file %s', filename));
end

line = '';
while ischar(line)
  line = cleanline(fgetl(fid))

  if isempty(line) | line==-1 | isempty(findstr(line, ':'))
    continue
  end

  % the line is not empty, which means that we have encountered a chunck of information
  if findstr(line, ':')~=length(line)
    [item, value] = strtok(line, ':');
    value(1) = ' ';         % remove the :
    value  = strtrim(value);
    item   = strtrim(item);
    item(findstr(item, '.')) = '_';
    item(findstr(item, ' ')) = '_';
    if ischar(item)
      eval(sprintf('file.%s = ''%s'';', item, value));
    else
      eval(sprintf('file.%s = %s;', item, value));
    end
  else
    subline = cleanline(fgetl(fid));
    error, the rest has not been implemented (yet)

  end
end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function line = cleanline(line)
if isempty(line) | line==-1
  return
end
comment = findstr(line, '//');
if ~isempty(comment)
  line(min(comment):end) = ' ';
end
line = strtrim(line);


text:
/**
 * @fileoverview Launches the given browser with the right configuration to be used via the Chrome Debugging Protocol
 *
 */

import * as path from 'path';

import { BrowserInfo, ILauncher, LauncherOptions } from '../../types';

/*
 * ------------------------------------------------------------------------------
 * Common
 * ------------------------------------------------------------------------------
 */

export abstract class Launcher implements ILauncher {
    protected pidFile: string = path.join(process.cwd(), 'cdp.pid');
    protected port: number = 9222;
    protected options: LauncherOptions = null;

    public constructor(options: LauncherOptions) {
        this.options = options;
    }

    /**
     * Launches browser with the given url and ready to be used with the Chrome Debugging Protocol.
     */
    public abstract async launch(url: string): Promise<BrowserInfo>;
}


text:
__author__ = 'bbowman@pacificbiosciences.com'

from pbmgx.segment.segment import Segment

class SegmentPair( object ):
    """
    A Class for representing a segment of a Nucmer Alignment
    """

    def __init__(self, reference, query):
        assert isinstance(reference, Segment)
        assert isinstance(query, Segment)
        self._reference = reference
        self._query = query

        if self.reference.forward == self.query.forward:
            self._orientation = 'same'
        else:
            self._orientation = 'opposite'

    @property
    def reference(self):
        return self._reference

    @property
    def query(self):
        return self._query

    @property
    def orientation(self):
        return self._orientation


text:
using System;
using System.Web.Http;
using System.Web.Mvc;
using SDammann.WebApi.Versioning.TestApi.Areas.HelpPage.ModelDescriptions;
using SDammann.WebApi.Versioning.TestApi.Areas.HelpPage.Models;

namespace SDammann.WebApi.Versioning.TestApi.Areas.HelpPage.Controllers
{
    /// <summary>
    /// The controller that will handle requests for the help page.
    /// </summary>
    public class HelpController : Controller
    {
        private const string ErrorViewName = "Error";

        public HelpController()
            : this(GlobalConfiguration.Configuration)
        {
        }

        public HelpController(HttpConfiguration config)
        {
            this.Configuration = config;
        }

        public HttpConfiguration Configuration { get; private set; }

        public ActionResult Index()
        {
            this.ViewBag.DocumentationProvider = this.Configuration.Services.GetDocumentationProvider();
            return this.View(this.Configuration.Services.GetApiExplorer().ApiDescriptions);
        }

        public ActionResult Api(string apiId)
        {
            if (!String.IsNullOrEmpty(apiId))
            {
                HelpPageApiModel apiModel = this.Configuration.GetHelpPageApiModel(apiId);
                if (apiModel != null)
                {
                    return this.View(apiModel);
                }
            }

            return this.View(ErrorViewName);
        }

        public ActionResult ResourceModel(string modelName)
        {
            if (!String.IsNullOrEmpty(modelName))
            {
                ModelDescriptionGenerator modelDescriptionGenerator = this.Configuration.GetModelDescriptionGenerator();
                ModelDescription modelDescription;
                if (modelDescriptionGenerator.GeneratedModels.TryGetValue(modelName, out modelDescription))
                {
                    return this.View(modelDescription);
                }
            }

            return this.View(ErrorViewName);
        }
    }
}


text:
package org.gradle.plugin.management.internal;

import org.gradle.plugin.management.PluginResolutionStrategy;

public interface PluginResolutionStrategyInternal extends PluginResolutionStrategy {

    PluginRequestInternal applyTo(PluginRequestInternal pluginRequest);
}


text:
function varargout = time_response_point_source(X,xs,conf)
%TIME_RESPONSE_POINT_SOURCE time response of a point source
%
%   Usage: [s,t] = time_response_point_source(X,xs,conf)
%
%   Input parameters:
%       X           - listener position / m
%       xs          - position of point source / m
%       conf        - configuration struct (see SFS_config)
%
%   Output parameters:
%       s           - simulated time response
%       t           - corresponding time axis / s
%
%   TIME_RESPONSE_POINT_SOURCE(X,xs,conf) simulates the impulse response of a
%   point source placed at xs at the given virtual microphone position X.
%   The length in samples of the impulse response is given by conf.N.
%   The actual calculation is done via sound_field_imp() and a loop over time t.
%   A similar result can be achieved by using ir_point_source() in combination
%   with dummy_irs().
%
%   See also: ir_point_source, sound_field_imp, freq_response_point_source

%*****************************************************************************
% The MIT License (MIT)                                                      *
%                                                                            *
% Copyright (c) 2010-2019 SFS Toolbox Developers                             *
%                                                                            *
% Permission is hereby granted,  free of charge,  to any person  obtaining a *
% copy of this software and associated documentation files (the "Software"), *
% to deal in the Software without  restriction, including without limitation *
% the rights  to use, copy, modify, merge,  publish, distribute, sublicense, *
% and/or  sell copies of  the Software,  and to permit  persons to whom  the *
% Software is furnished to do so, subject to the following conditions:       *
%                                                                            *
% The above copyright notice and this permission notice shall be included in *
% all copies or substantial portions of the Software.                        *
%                                                                            *
% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
% IMPLIED, INCLUDING BUT  NOT LIMITED TO THE  WARRANTIES OF MERCHANTABILITY, *
% FITNESS  FOR A PARTICULAR  PURPOSE AND  NONINFRINGEMENT. IN NO EVENT SHALL *
% THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
% LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT, TORT  OR OTHERWISE, ARISING *
% FROM,  OUT OF  OR IN  CONNECTION  WITH THE  SOFTWARE OR  THE USE  OR OTHER *
% DEALINGS IN THE SOFTWARE.                                                  *
%                                                                            *
% The SFS Toolbox  allows to simulate and  investigate sound field synthesis *
% methods like wave field synthesis or higher order ambisonics.              *
%                                                                            *
% https://sfs.readthedocs.io                            sfstoolbox@gmail.com *
%*****************************************************************************

%% ===== Checking of input  parameters ==================================
nargmin = 3;
nargmax = 3;
narginchk(nargmin,nargmax);
isargposition(X);
isargxs(xs);
isargstruct(conf);

%% ===== Configuration ==================================================
fs = conf.fs;
N = conf.N;
showprogress = conf.showprogress;
useplot = conf.plot.useplot;

%% ===== Computation ====================================================
% Disable progress bar and plotting for sound_field_imp()
conf.showprogress = false;
conf.plot.useplot = false;
% Get the position of the loudspeaker from point source position.
% NOTE: its directivity [0 -1 0] will be ignored
x0 = [xs 0 -1 0 1];
% Generate time axis
t = (0:N-1)'/fs;
s = zeros(1,length(t));
for ii = 1:length(t)
    if showprogress, progress_bar(ii,length(t)); end
    % Calculate sound field at the listener position
    p = sound_field_imp(X(1),X(2),X(3),x0,'ps',dirac_imp(),t(ii),conf);
    s(ii) = real(p);
end

% Return parameter
if nargout>0, varargout{1}=s; end
if nargout>1, varargout{2}=t; end

%% ===== Plotting ========================================================
if nargout==0 || useplot
    figure;
    figsize(conf.plot.size(1),conf.plot.size(2),conf.plot.size_unit);
    plot(t*1000,s);
    ylabel('amplitude');
    xlabel('time / ms');
end


text:
package org.ovirt.engine.ui.common.widget.form;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.ovirt.engine.ui.uicommonweb.models.EntityModel;
import org.ovirt.engine.ui.uicompat.Event;
import org.ovirt.engine.ui.uicompat.IEventListener;
import org.ovirt.engine.ui.uicompat.PropertyChangedEventArgs;

public class FormBuilder {

    private final AbstractFormPanel formPanel;
    private final List<FormItem> items = new ArrayList<FormItem>();

    // Maps model property names to corresponding items, used to update
    // form items whenever the given model property changes its value
    private final Map<String, List<FormItem>> propertyNameMap = new HashMap<String, List<FormItem>>();

    private EntityModel<?> model;

    public FormBuilder(AbstractFormPanel formPanel, int numOfColumns, int numOfRows) {
        this.formPanel = formPanel;

        formPanel.addFormDetailView(numOfRows, numOfColumns);
    }

    /**
     * Set the relative width of the column in bootstrap grid columns, acceptable values are between 1 and 12.
     * Make sure your total for all columns does not exceed 12 or your results will be unpredictable.
     * @param columnNum The column you want to set the relative width for.
     * @param widthInColumns The number of grid columns you want your column to occupy.
     */
    public void setRelativeColumnWidth(int columnNum, int widthInGridColumns) {
        if (widthInGridColumns < 1 || widthInGridColumns > 12) {
            throw new IllegalArgumentException("The widthInGridColumns has to be between 1 and 12"); //$NON-NLS-1$
        }
        formPanel.setRelativeColumnWidth(columnNum, widthInGridColumns);
    }

    public void addFormItem(FormItem item) {
        addFormItem(item, 6, 6);
    }

    /**
     * Adds new item to the form panel.
     */
    public void addFormItem(FormItem item, int labelWidth, int valueWidth) {
        // Adopt item
        item.setFormPanel(formPanel);

        // Validate and add item
        if (item.isValid()) {
            formPanel.addFormItem(item, labelWidth, valueWidth);
            items.add(item);

            // Update property name mapping, if necessary
            String isAvailablePropertyName = item.getIsAvailablePropertyName();
            if (isAvailablePropertyName != null) {
                getItemsForPropertyName(isAvailablePropertyName).add(item);
            }
        }
    }

    List<FormItem> getItemsForPropertyName(String propertyName) {
        if (!propertyNameMap.containsKey(propertyName)) {
            propertyNameMap.put(propertyName, new ArrayList<FormItem>());
        }
        return propertyNameMap.get(propertyName);
    }

    /**
     * Updates all items within the form panel.
     */
    public void update(EntityModel<?> model) {
        // Detach property change listener from old model
        if (this.model != null) {
            this.model.getPropertyChangedEvent().removeListener(propertyChangedEventListener);
        }

        // Adopt new model
        this.model = model;

        // Attach property change listener to new model
        this.model.getPropertyChangedEvent().addListener(propertyChangedEventListener);

        // Update all form items
        for (FormItem item : items) {
            item.update();
        }
    }

    private final IEventListener<PropertyChangedEventArgs> propertyChangedEventListener = new IEventListener<PropertyChangedEventArgs>() {
        @Override
        public void eventRaised(Event<? extends PropertyChangedEventArgs> ev, Object sender, PropertyChangedEventArgs args) {
            String propertyName = args.propertyName;
            List<FormItem> formItems = propertyNameMap.get(propertyName);
            if (formItems != null) {
                for (FormItem item : formItems) {
                    item.update();
                }
            }
        }
    };

}