text:
package org.apache.storm.hbase.state;

import com.google.common.primitives.UnsignedBytes;
import org.apache.storm.hbase.common.HBaseClient;
import org.apache.storm.state.DefaultStateSerializer;
import org.junit.Before;
import org.junit.Test;

import java.util.Map;
import java.util.NavigableMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

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

/**
 * Unit tests for {@link HBaseKeyValueState}
 */
public class HBaseKeyValueStateTest {
    private static final String COLUMN_FAMILY = "cf";
    private static final String NAMESPACE = "namespace";

    HBaseClient mockClient;
    HBaseKeyValueState<String, String> keyValueState;
    ConcurrentNavigableMap<byte[], NavigableMap<byte[], NavigableMap<byte[], byte[]>>> mockMap;

    @Before
    public void setUp() throws Exception {
        mockMap = new ConcurrentSkipListMap<>(UnsignedBytes.lexicographicalComparator());
        mockClient = HBaseClientTestUtil.mockedHBaseClient(mockMap);
        keyValueState = new HBaseKeyValueState<>(mockClient, COLUMN_FAMILY, NAMESPACE,
                new DefaultStateSerializer<String>(), new DefaultStateSerializer<String>());
    }

    @Test
    public void testPutAndGet() throws Exception {
        keyValueState.put("a", "1");
        keyValueState.put("b", "2");
        assertEquals("1", keyValueState.get("a"));
        assertEquals("2", keyValueState.get("b"));
        assertEquals(null, keyValueState.get("c"));
    }

    @Test
    public void testPutAndDelete() throws Exception {
        keyValueState.put("a", "1");
        keyValueState.put("b", "2");
        assertEquals("1", keyValueState.get("a"));
        assertEquals("2", keyValueState.get("b"));
        assertEquals(null, keyValueState.get("c"));
        assertEquals("1", keyValueState.delete("a"));
        assertEquals(null, keyValueState.get("a"));
        assertEquals("2", keyValueState.get("b"));
        assertEquals(null, keyValueState.get("c"));
    }

    @Test
    public void testPrepareCommitRollback() throws Exception {
        keyValueState.put("a", "1");
        keyValueState.put("b", "2");
        keyValueState.prepareCommit(1);
        keyValueState.put("c", "3");
        assertArrayEquals(new String[]{"1", "2", "3"}, getValues());
        keyValueState.rollback();
        assertArrayEquals(new String[]{null, null, null}, getValues());
        keyValueState.put("a", "1");
        keyValueState.put("b", "2");
        keyValueState.prepareCommit(1);
        keyValueState.commit(1);
        keyValueState.put("c", "3");
        assertArrayEquals(new String[]{"1", "2", "3"}, getValues());
        keyValueState.rollback();
        assertArrayEquals(new String[]{"1", "2", null}, getValues());
        keyValueState.put("c", "3");
        assertEquals("2", keyValueState.delete("b"));
        assertEquals("3", keyValueState.delete("c"));
        assertArrayEquals(new String[]{"1", null, null}, getValues());
        keyValueState.prepareCommit(2);
        assertArrayEquals(new String[]{"1", null, null}, getValues());
        keyValueState.commit(2);
        assertArrayEquals(new String[]{"1", null, null}, getValues());
        keyValueState.put("b", "2");
        keyValueState.prepareCommit(3);
        keyValueState.put("c", "3");
        assertArrayEquals(new String[]{"1", "2", "3"}, getValues());
        keyValueState.rollback();
        assertArrayEquals(new String[]{"1", null, null}, getValues());
    }

    private String[] getValues() {
        return new String[]{
                keyValueState.get("a"),
                keyValueState.get("b"),
                keyValueState.get("c")
        };
    }
}


text:
package org.fidonet.binkp.mina2;

import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.service.DefaultTransportMetadata;
import org.apache.mina.core.session.IoSessionConfig;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.ProtocolCodecSession;
import org.fidonet.binkp.common.Connector;
import org.fidonet.binkp.common.LinksInfo;
import org.fidonet.binkp.common.SessionContext;
import org.fidonet.binkp.common.SessionState;
import org.fidonet.binkp.common.config.ServerRole;
import org.fidonet.binkp.common.config.StationConfig;
import org.fidonet.binkp.common.events.*;
import org.fidonet.binkp.common.io.FileInfo;
import org.fidonet.binkp.mina2.codec.BinkDataCodecFactory;
import org.fidonet.binkp.mina2.codec.TrafficCrypterCodecFilter;
import org.fidonet.binkp.mina2.handler.BinkSessionHandler;
import org.fidonet.events.EventHandler;
import org.fidonet.types.FTNAddr;
import org.fidonet.types.Link;
import org.junit.Assert;
import org.junit.Test;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.SocketAddress;
import java.util.LinkedList;

/**
 * Created by IntelliJ IDEA.
 * Author: Vladimir Kravets
 * E-Mail: vova.kravets@gmail.com
 * Date: 9/26/12
 * Time: 4:57 PM
 */
public class Mina2ClientTest {

    private class ClientMock extends Connector implements Runnable {

        private ProtocolCodecSession session;
        private SessionContext sessionContext;

        public ClientMock(SessionContext sessionContext) {
            this.sessionContext = sessionContext;
        }

        @Override
        public void run(SessionContext sessionContext) throws Exception {
            session = new ProtocolCodecSession();
            session.getFilterChain().addLast("crypt", new TrafficCrypterCodecFilter());
            session.getFilterChain().addLast("codec", new ProtocolCodecFilter(new BinkDataCodecFactory()));
            session.setHandler(new BinkSessionHandler(sessionContext, getEventBus()));
            session.setTransportMetadata(new DefaultTransportMetadata(
                    "mina", "dummy", false, true,
                    SocketAddress.class, IoSessionConfig.class, Object.class));
            sessionContext.setServerRole(ServerRole.CLIENT);
            session.getHandler().sessionOpened(session);
            sessionContext.setState(SessionState.STATE_IDLE);
        }

        @Override
        public void stop() {
            session.close();
        }

        public ProtocolCodecSession getSession() {
            return session;
        }

        public void writeStreamToSession(InputStream stream) throws Exception {
            int bufSize = 10;
            int size = 0;
            byte[] bytes = new byte[bufSize];
//            ProtocolDecoder decoder = new BinkDataDecoder();
            while ((size = stream.read(bytes)) != -1) {
                IoBuffer buf = IoBuffer.allocate(size);
                buf.put(bytes, 0, size);
                buf.flip();
                //decoder.decode(session, buf, session.getDecoderOutput());
                session.getFilterChain().fireMessageReceived(buf);
                Thread.sleep(100);
            }
            Thread.sleep(1000);
            sessionContext.setState(SessionState.STATE_END);
        }

        @Override
        public void run() {
            try {
                run(sessionContext);
                InputStream recvRawData = ClientMock.class.getClassLoader().getResourceAsStream("recv_stream.bin");
                ClientMock.this.writeStreamToSession(recvRawData);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        public void registerEvent(EventHandler eventHandler) {
            getEventBus().subscribe(eventHandler);
        }
    }

    private Boolean connected = false;
    private Boolean disconnected = false;
    private Boolean fileReceived = false;
    private DisconnectedEventHandler disconnectedEventHandler;
    private ConnectedEventHandler connectedEventHandler;
    private FileReceivedEventHandler fileReceivedEventHandler;

    @Test
    public void testBaseFlow() throws InterruptedException {
        StationConfig config = new StationConfig("Test Station", "Vasya Pupkin", "Odessa, Ukraine", "BINKP", "2:467/110.113");
        final FTNAddr node = new FTNAddr("2:467/110");
        LinksInfo linksInfo = new LinksInfo(
                new LinkedList<Link>() {
                    {
                        add(new Link(node,
                                        new LinkedList<FTNAddr>() {
                                            {
                                                add(new FTNAddr("2:467/110.113"));
                                            }
                                        },
                                        "pass_i_f", "localhost", 24554
                                )
                        );
                    }
                }
        );
        linksInfo.setCurLink(node);
        SessionContext sessionContext = new SessionContext(config, linksInfo);
        sessionContext.getStationConfig().setCryptMode(true);
        ClientMock clientMock = new ClientMock(sessionContext);
        registerEvents(clientMock);
        Thread thread = new Thread(clientMock);
        thread.start();
        thread.join();
        FileInfo fileInfo = sessionContext.getRecvFiles().peek().getInfo();
        Assert.assertEquals("0000FF8F.WE5", fileInfo.getName());
        Assert.assertEquals(766, fileInfo.getSize());
        Assert.assertEquals(true, fileInfo.isFinished());
        Assert.assertEquals(true, connected);
        Assert.assertEquals(true, disconnected);
        Assert.assertEquals(true, fileReceived);
    }

    private void registerEvents(ClientMock client) {
        connectedEventHandler = new ConnectedEventHandler() {
            @Override
            public void onEventHandle(ConnectedEvent event) {
                connected = true;
            }
        };
        client.registerEvent(connectedEventHandler);

        disconnectedEventHandler = new DisconnectedEventHandler() {
            @Override
            public void onEventHandle(DisconnectedEvent event) {
                disconnected = true;
            }
        };
        client.registerEvent(disconnectedEventHandler);

        fileReceivedEventHandler = new FileReceivedEventHandler() {
            @Override
            public void onEventHandle(FileReceivedEvent event) {
                fileReceived = true;
                FileInfo expectedInfo = new FileInfo("0000FF8F.WE5", 766, 1348664500L);
                Assert.assertEquals(expectedInfo, event.getFile().getInfo());
                Assert.assertEquals(true, event.getFile().getInfo().isFinished());
                ByteArrayOutputStream outStream = (ByteArrayOutputStream) event.getFile().getStream();
                Assert.assertEquals(766, outStream.toByteArray().length);
            }
        };
        client.registerEvent(fileReceivedEventHandler);
    }

}

redpajama_set_name: RedPajamaGithub


text:
"""
    mothership.kv

    Package for interacting with the KV store in mothership
"""

from sqlalchemy import or_, desc, MetaData

import mothership
from mothership.mothership_models import *

class KVError(Exception):
    pass

def new(fqdn, key, value):
    """
    Constructor that takes a host.realm.site style fqdn.
    """
    hostname, realm, site_id = mothership.split_fqdn(fqdn)
    kv = KV(key, value, hostname, realm, site_id)
    return kv

def select(cfg, fqdn, key, value=None):
    """
    Returns a specific KV object.
    """
    hostname, realm, site_id = mothership.split_fqdn(fqdn)
    results = cfg.dbsess.query(KV).\
            filter(KV.hostname==hostname).\
            filter(KV.realm==realm).\
            filter(KV.site_id==site_id).\
            filter(KV.key==key)
    if value:
        results = results.filter(KV.value==value)
    kv = results.first()
    return kv

def collect(cfg, fqdn, key=None, value=None):
    """
    Returns a list of all matches.
    """
    results = cfg.dbsess.query(KV)

    if fqdn != None:
        hostname, realm, site_id = mothership.split_fqdn(fqdn)
        results = results.\
            filter(or_(KV.site_id==site_id, KV.site_id==None)).\
            filter(or_(KV.realm==realm, KV.realm==None)).\
            filter(or_(KV.hostname==hostname, KV.hostname==None)).\
            order_by(desc(KV.hostname), desc(KV.realm), desc(KV.site_id))
    if key:
        results = results.filter(KV.key==key)
    if value:
        results = results.filter(KV.value==value)

    kvs = results.all()
    return kvs

def add(cfg, fqdn, key, value):
    """
    Add a new value with set semantics.
    """
    # make sure we have a value
    if not value:
        raise KVError('No value specified!')

    # if we're adding a tag, make sure it exists, first!
    if key == 'tag':
        tag = cfg.dbsess.query(Tag).filter(Tag.name==value).first()
        if not tag:
            print "Trying to apply a nonexistent tag. Abort! Abort!"
            raise KVError('Try "ship tag --help" for more info')

    # make sure the serverpath exists
    hostname, realm, site_id = mothership.split_fqdn(fqdn)
    if hostname != None:
        results = cfg.dbsess.query(Server)
        results = results.\
            filter(Server.site_id==site_id).\
            filter(Server.realm==realm).\
            filter(Server.hostname==hostname).\
            first()
        if not results:
            raise KVError('Trying to apply a tag to a nonexistent host. Abort!')

    # Check for duplicate key=value.
    kv = select(cfg, fqdn, key, value)
    if kv:
        print "that key=value pair exists already!"
        ans = raw_input("Do you want to update it? (y/n): ")
        if ans == "Y" or ans == "y":
            print "updating key=value"
            kv = upsert(cfg, fqdn, key, value)
            return kv
        else:
            print "key=value unchanged, exiting."
            return kv
    print "no existing key=value found, inserting."
    if fqdn == '':
        print "this will apply %s=%s globally" % (key, value)
        ans = raw_input("are you sure you want to do this? (y/n): ")
        if ans == "Y" or ans == "y":
            kv = new(fqdn, key, value)
            cfg.dbsess.add(kv)
            cfg.dbsess.commit()
            return kv
    kv = new(fqdn, key, value)
    cfg.dbsess.add(kv)
    cfg.dbsess.commit()
    return kv

def upsert(cfg, fqdn, key, value):
    """
    Insert a new value or update existing.
    """
    kv = select(cfg, fqdn, key)
    if not kv:
        print "key=value not found, adding"
        kv = new(fqdn, key, value)
    print "key=value found, updating"
    kv.value = value
    cfg.dbsess.add(kv)
    cfg.dbsess.commit()
    return kv

def delete(cfg, fqdn, key, value):
    """
    Delete a row matching both key and value.
    """
    kv = select(cfg, fqdn, key, value=value)
    if kv:
        cfg.dbsess.delete(kv)
        cfg.dbsess.commit()
    else:
        print "key=value not found, exiting."


text:
package com.github.dreamhead.moco;

import org.apache.http.client.HttpResponseException;
import org.junit.Test;

import java.io.IOException;

import static com.github.dreamhead.moco.Moco.*;
import static com.github.dreamhead.moco.helper.RemoteTestUtils.root;
import static com.github.dreamhead.moco.Runner.running;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

public class MocoXmlTest extends AbstractMocoHttpTest {
    @Test
    public void should_return_content_based_on_xpath() throws Exception {
        server.request(eq(xpath("/request/parameters/id/text()"), "1")).response("foo");
        server.request(eq(xpath("/request/parameters/id/text()"), "2")).response("bar");

        running(server, new Runnable() {
            @Override
            public void run() throws IOException {
                assertThat(helper.postFile(root(), "foo.xml"), is("foo"));
                assertThat(helper.postFile(root(), "bar.xml"), is("bar"));
            }
        });
    }

    @Test(expected = HttpResponseException.class)
    public void should_not_return_anything_for_mismatch_xpath() throws Exception {
        server.request(eq(xpath("/request/parameters/id/text()"), "3")).response("foo");
        running(server, new Runnable() {
            @Override
            public void run() throws Exception {
                helper.postFile(root(), "foo.xml");
            }
        });
    }

    @Test(expected = HttpResponseException.class)
    public void should_not_return_anything_for_unknown_xpath() throws Exception {
        server.request(eq(xpath("/response/parameters/id/text()"), "3")).response("foo");
        running(server, new Runnable() {
            @Override
            public void run() throws Exception {
                helper.postFile(root(), "foo.xml");
            }
        });
    }

    @Test
    public void should_return_content_based_on_xpath_with_many_elements() throws Exception {
        server.request(eq(xpath("/request/parameters/id/text()"), "2")).response("bar");

        running(server, new Runnable() {
            @Override
            public void run() throws IOException {
                assertThat(helper.postFile(root(), "foobar.xml"), is("bar"));
            }
        });
    }

    @Test
    public void should_match_exact_xml() throws Exception {
        server.request(xml(file("src/test/resources/foo.xml"))).response("foo");

        running(server, new Runnable() {
            @Override
            public void run() throws IOException {
                assertThat(helper.postFile(root(), "foo.xml"), is("foo"));
            }
        });
    }

    @Test
    public void should_match_xml() throws Exception {
        server.request(xml(text("<request><parameters><id>1</id></parameters></request>"))).response("foo");

        running(server, new Runnable() {
            @Override
            public void run() throws IOException {
                assertThat(helper.postFile(root(), "foo.xml"), is("foo"));
            }
        });
    }

    @Test(expected = IOException.class)
    public void should_throw_exception_for_unknown_content() throws Exception {
        server.request(xml(text("<request><parameters><id>1</id></parameters></request>"))).response("foo");

        running(server, new Runnable() {
            @Override
            public void run() throws IOException {
                helper.postContent(root(), "blah");
            }
        });
    }

    @Test
    public void should_return_content_based_on_xpath_existing() throws Exception {
        server.request(exist(xpath("/request/parameters/id/text()"))).response("foo");

        running(server, new Runnable() {
            @Override
            public void run() throws IOException {
                assertThat(helper.postFile(root(), "foo.xml"), is("foo"));
            }
        });
    }
}


text:
<?php
declare(strict_types = 1);

namespace Suitwalk\Infrastructure\Repository\Event;

use Doctrine\Common\Persistence\ObjectRepository;
use Suitwalk\Domain\Event\Event;
use Suitwalk\Domain\Event\GetLatestEventInterface;

final class GetLatestEvent implements GetLatestEventInterface
{
    /**
     * @var ObjectRepository
     */
    private $repository;

    public function __construct(ObjectRepository $repository)
    {
        $this->repository = $repository;
    }

    public function __invoke() : Event
    {
        return $this->repository->findOneBy([], ['date' => 'desc']);
    }
}


text:
BSLS_IDENT_RCSID(ball_observeradapter_cpp,"$Id$ $CSID$")

#include <ball_context.h>                       // for testing only
#include <ball_record.h>                        // for testing only
#include <ball_recordattributes.h>              // for testing only
#include <ball_transmission.h>                  // for testing only
#include <ball_userfields.h>                    // for testing only
#include <ball_userfieldvalue.h>                // for testing only

namespace BloombergLP {
namespace ball {

                        // ---------------------
                        // class ObserverAdapter
                        // ---------------------

// CREATORS
ObserverAdapter::~ObserverAdapter()
{
}

}  // close package namespace
}  // close enterprise namespace

// ----------------------------------------------------------------------------
// Copyright 2015 Bloomberg Finance L.P.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ----------------------------- END-OF-FILE ----------------------------------


text:
<?php

class Forum
{
	private $listCat;
	private $listPost;
	private $listCom;

	public function getListCat(){
		return $this->listCat;
	}

	public function setListCat($listCat){
		if(is_array($listCat)){
			$this->listCat = $listCat;
		}
	}

	public function getListPost(){
		return $this->listPost;
	}

	public function setListPost($ListPost){
		$this->listPost = $ListPost;
	}

	public function getListCom(){
		return $this->listCom;
	}

	public function setListCom($ListCom){
		$this->listCom = $ListCom;
	}
}

?>


text:
//
//  TBRSSLCertificateModel.h
//
//  Created by Luciano Marisi on 14/07/2014.
//  Copyright (c) 2014 TechBrewers LTD. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface TBRSSLCertificateModel : NSObject

@property (nonatomic, copy, readonly) NSString *MD5Fingerprint;
@property (nonatomic, copy, readonly) NSString *SHA1Fingerprint;

/**
 *  Designated initializer for creating TBRSSLCertificateModel object
 *
 *  @param MD5Fingerprint  MD5 fingerprint string
 *  @param SHA1Fingerprint SHA1 fingerprint string
 *
 *  @return The initialized object
 */
- (instancetype)initWithMD5Fingerprint:(NSString *)MD5Fingerprint
                       SHA1Fingerprint:(NSString *)SHA1Fingerprint __attribute__((objc_designated_initializer));

/**
 *  Initializer for creating TBRSSLCertificateModel object with certificate data from connection delegate
 *
 *  @param certificateData The DER representation of the certificate
 *
 *  @return The initialized object
 */
- (instancetype)initWithCertificateData:(NSData *)certificateData;

- (BOOL)isEqualToSSLCertificateModel:(TBRSSLCertificateModel *)SSLCertificateModel;

@end


text:
import {statementType} from "../_utils";
import * as Statements from "../../../src/abap/2_statements/statements";

const tests = [
  "SELECT-OPTIONS foo FOR bar.",
  "SELECT-OPTIONS s_trkorr FOR e070-trkorr.",
  "SELECT-OPTIONS s_trkorr FOR e070-trkorr OBLIGATORY.",
  "SELECT-OPTIONS s_moo FOR zfoo-bar MEMORY ID zfoo.",
  "SELECT-OPTIONS s_moo FOR zfoo-bar NO-EXTENSION.",
  "SELECT-OPTIONS F1 FOR foo-bar VISIBLE LENGTH 20 MODIF ID F1.",
  "SELECT-OPTIONS s_matnr FOR mara-matnr MODIF ID sel.",
  "SELECT-OPTIONS s_moo FOR zfoo-bar NO-EXTENSION NO INTERVALS.",
  "SELECT-OPTIONS s_qnum FOR aqgqcat-qnum MATCHCODE OBJECT zquery.",
  "SELECT-OPTIONS s_num FOR aqgqcat-num OBLIGATORY DEFAULT 'ASDF'.",
  "SELECT-OPTIONS s_moo FOR zfoo-bar NO INTERVALS MEMORY ID zfoo.",
  "SELECT-OPTIONS s_icon FOR icon-name DEFAULT 'foo' OPTION CP.",
  "SELECT-OPTIONS foo FOR (foo=>bar).",
  "select-options bar for foo no-display.",
  "SELECT-OPTIONS s_foo FOR bar DEFAULT 'AA' TO 'ZZ'.",
  "SELECT-OPTIONS s_bar FOR foo-bar NO-EXTENSION OBLIGATORY.",
  "SELECT-OPTIONS s_att FOR _att NO INTERVALS LOWER CASE.",
  "SELECT-OPTIONS s_id FOR /foo/bar-id NO INTERVALS.",
  "SELECT-OPTIONS so_fr FOR from MODIF ID 123.",
  "SELECT-OPTIONS s_startd FOR w_startd DEFAULT sy-datum TO sy-datum.",
  "SELECT-OPTIONS sp$00004 FOR moo-boo MEMORY ID foo.",
  "SELECT-OPTIONS s_name FOR field NO DATABASE SELECTION.",
  "SELECT-OPTIONS s_field FOR table-field DEFAULT 'A' OPTION EQ SIGN E.",
  "select-options date for <fs_booking>-date.",
  "SELECT-OPTIONS s_ghi FOR gs_dummy-ghi MODIF ID rt*.",
  "SELECT-OPTIONS foo-bar FOR foobar-asdf.",
];

statementType(tests, "SELECT-OPTIONS", Statements.SelectOption);


text:
import os

from .. import base
from girder.constants import SettingKey
from girder.utility import config, mail_utils

def setUpModule():
    pluginRoot = os.path.join(os.path.dirname(os.path.dirname(__file__)),
                              'test_plugins')
    conf = config.getConfig()
    conf['plugins'] = {'plugin_directory': pluginRoot}
    base.enabledPlugins.append('mail_test')

    base.startServer()

def tearDownModule():
    base.stopServer()

class MailTestCase(base.TestCase):
    """
    Test the email utilities.
    """

    def testEmailAdmins(self):
        self.assertTrue(base.mockSmtp.isMailQueueEmpty())

        admin1, admin2 = [self.model('user').createUser(
            firstName='Admin%d' % i, lastName='Admin', login='admin%d' % i,
            password='password', admin=True, email='admin%d@admin.com' % i)
            for i in range(2)]

        # Set the email from address
        self.model('setting').set(SettingKey.EMAIL_FROM_ADDRESS, 'a@test.com')

        # Test sending email to admin users
        mail_utils.sendEmail(text='hello', toAdmins=True)
        self.assertTrue(base.mockSmtp.waitForMail())

        lines = base.mockSmtp.getMail().strip().splitlines()
        self.assertTrue('Subject: [no subject]' in lines)
        self.assertTrue('To: admin0@admin.com, admin1@admin.com' in lines)
        self.assertTrue('From: a@test.com' in lines)
        self.assertEqual(lines[-1], 'hello')

        # Test sending email to multiple recipients
        self.assertTrue(base.mockSmtp.isMailQueueEmpty())
        mail_utils.sendEmail(to=('a@abc.com', 'b@abc.com'), text='world',
                             subject='Email alert')
        self.assertTrue(base.mockSmtp.waitForMail())

        lines = base.mockSmtp.getMail().strip().splitlines()
        self.assertTrue('Subject: Email alert' in lines)
        self.assertTrue('To: a@abc.com, b@abc.com' in lines)
        self.assertTrue('From: a@test.com' in lines)
        self.assertEqual(lines[-1], 'world')

        # Pass nonsense in the "to" field, check exception
        x = 0
        try:
            mail_utils.sendEmail(text='hello', to=None)
        except Exception as e:
            x = 1
            self.assertEqual(
                e.message, 'You must specify a "to" address or list of '
                'addresses or set toAdmins=True when calling sendEmail.')

        self.assertEqual(x, 1)

    def testPluginTemplates(self):
        val = 'OVERRIDE CORE FOOTER'
        self.assertEqual(mail_utils.renderTemplate('_footer.mako').strip(), val)

        # Make sure it also works from in-mako import statements
        content = mail_utils.renderTemplate('temporaryAccess.mako', {
            'url': 'x'
        })
        self.assertTrue(val in content)


text:
var HttpStreamingJsonSource = require('../lib/datasource/http-streaming-json-source');
var Announces = require('../lib/vis/announces');
var AnnouncePayload = require('../lib/vis/announces/payload');

class TrackerAnnounces {
  constructor(container, api, appId, groupBy) {
    this.url = api + "?app_id=" + appId + "&substr=obj@chihaya";
    this.announces = new Announces(container, groupBy);
  }

  run() {
    var datasource = new HttpStreamingJsonSource(this.url, this.transform(), this.getHandler());
    datasource.runWithRepeat();
  }

  transform() {
    return function(msg) {
      //console.log("hoola", msg);
      if(msg.message == "obj" && msg.object["chihaya"]) {
        var log = msg.object["chihaya"];
        if (log.msg == "generated announce response" && log.req) {
          var req = log.req;
          return new AnnouncePayload(req.peer.IP, req.infoHash, req.left, req.downloaded, req.uploaded, new Date(log.time));
        }
        console.error("Cannot transform, invalid announce response ", msg);
        return null;
      }
      console.error("Cannot transform, invalid log ", msg);
      return null;
    }.bind(this);
  }

  getHandler() {
    let handler = this.announces.requestHandler();
    return function(entry) {
      switch(entry.type) {
        case "data":
          if(entry.msg) {
            setTimeout(() => handler(entry.msg), 0);
          }
          break;
        case "error":
            console.error(entry);
            break;
        case "stat_chunk":
            break;
        default:
            console.error("Not sure how to handle the emitted entry", entry);
      }
    }.bind(this);
  }
}

module.exports = TrackerAnnounces;


text:
/// @file  Manifold.hpp
/// @brief Data structures for manifolds
/// @author Adam Getchell

#ifndef CDT_PLUSPLUS_MANIFOLD_HPP
#define CDT_PLUSPLUS_MANIFOLD_HPP

#include <cstddef>
#include <unordered_set>
#include <utility>

#include "Geometry.hpp"

namespace manifolds
{
  /// Manifold class template
  /// @tparam dimension Dimensionality of manifold
  template <int dimension>
  class Manifold;

  /// 3D Manifold
  template <>
  class [[nodiscard("This contains data!")]] Manifold<3>
  {
    using Triangulation = foliated_triangulations::FoliatedTriangulation_3;
    using Geometry      = Geometry_3;

    /// @brief The data structure of geometric and combinatorial relationships
    Triangulation m_triangulation;

    /// @brief The data structure of scalar values for computations
    Geometry m_geometry;

   public:
    /// @brief Dimensionality of the manifold
    /// @details Used to determine the manifold dimension at compile-time
    static int constexpr dimension                   = 3;

    /// @brief Default dtor
    ~Manifold()                                      = default;

    /// @brief Default ctor
    Manifold()                                       = default;

    /// @brief Default copy ctor
    Manifold(Manifold const& other)                  = default;

    /// @brief Default copy assignment
    auto operator=(Manifold const& other)->Manifold& = default;

    /// @brief Default move ctor
    Manifold(Manifold && other)                      = default;

    /// @brief Default move assignment
    auto operator=(Manifold&& other)->Manifold&      = default;

    /// @brief Non-member swap function for Manifolds.
    /// @details Used for no-except updates of manifolds after moves.
    /// @param swap_from The value to be swapped from. Assumed to be discarded.
    /// @param swap_into The value to be swapped into.
    friend void swap(Manifold<3> & swap_from, Manifold<3> & swap_into) noexcept
    {
#ifndef NDEBUG
      spdlog::debug("{} called.\n", __PRETTY_FUNCTION__);
#endif
      using std::swap;
      swap(swap_from.m_triangulation, swap_into.m_triangulation);
      swap(swap_from.m_geometry, swap_into.m_geometry);
    }  // swap

    /// @brief Construct manifold from a Foliated triangulation
    /// @param t_foliated_triangulation Triangulation used to construct manifold
    explicit Manifold(Triangulation t_foliated_triangulation)
        : m_triangulation{std::move(t_foliated_triangulation)}
        , m_geometry{get_triangulation()}
    {}

    /// @brief Construct manifold using arguments
    /// @param t_desired_simplices Number of desired simplices
    /// @param t_desired_timeslices Number of desired timeslices
    /// @param t_initial_radius Radius of first timeslice
    /// @param t_foliation_spacing Radial separation between timeslices
    Manifold(Int_precision t_desired_simplices,
             Int_precision t_desired_timeslices,
             double        t_initial_radius    = INITIAL_RADIUS,
             double        t_foliation_spacing = FOLIATION_SPACING)
        : Manifold{
              Triangulation{t_desired_simplices, t_desired_timeslices,
                            t_initial_radius, t_foliation_spacing}
    }
    {}

    /// @brief Construct manifold from Causal_vertices
    /// Pass-by-value-then-move.
    /// @param causal_vertices Causal_vertices to place into the Manifold
    /// @param t_initial_radius Radius of first timeslice
    /// @param t_foliation_spacing Radial separation between timeslices
    explicit Manifold(Causal_vertices_t<3> const& causal_vertices,
                      double t_initial_radius    = INITIAL_RADIUS,
                      double t_foliation_spacing = FOLIATION_SPACING)
        : Manifold{
              Triangulation{causal_vertices, t_initial_radius,
                            t_foliation_spacing}
    }
    {}

    /// @brief Update the Manifold data structures
    void update()
    try
    {
#ifndef NDEBUG
      spdlog::debug("{} called.\n", __PRETTY_FUNCTION__);
#endif
      update_triangulation();
      update_geometry();
    }
    catch (std::system_error const& ex)
    {
      spdlog::trace("Exception thrown: {}\n", ex.what());
    }  // update

    /// @return A read-only reference to the triangulation
    [[nodiscard]] auto get_triangulation() const noexcept
        -> Triangulation const&
    {
      return std::cref(m_triangulation);
    }  // get_triangulation

    /// @return A mutable reference to the triangulation
    [[nodiscard]] auto triangulation()->Triangulation&
    {
      return m_triangulation;
    }  // triangulation

    /// @return A read-only reference to the Geometry
    [[nodiscard]] auto get_geometry() const->Geometry const&
    {
      return m_geometry;
    }  // get_geometry

    /// @brief Forwarding to FoliatedTriangulation_3.is_foliated()
    /// @return True if the Manifold triangulation is foliated
    [[nodiscard]] auto is_foliated() const->bool
    {
      return m_triangulation.is_foliated();
    }  // is_foliated

    /// @brief Forwarding to FoliatedTriangulation.is_delaunay()
    /// @return True if the Manifold triangulation is Delaunay
    [[nodiscard]] auto is_delaunay() const->bool
    {
      return m_triangulation.is_delaunay();
    }  // is_delaunay

    /// @brief Forwarding to FoliatedTriangulation.is_tds_valid()
    /// @return True if the TriangulationDataStructure is valid
    [[nodiscard]] auto is_valid() const->bool
    {
      return m_triangulation.is_tds_valid();
    }  // is_valid

    /// @return If base data structures are correct
    [[nodiscard]] auto is_correct() const->bool
    {
      return m_triangulation.is_correct();
    }  // is_correct

    /// @brief Perfect forwarding to FoliatedTriangulation_3.is_vertex()
    /// @tparam VertexType The vertex type
    /// @param t_vertex_candidate The vertex to check
    /// @return True if the vertex candidate is a vertex
    template <typename VertexType>
    [[nodiscard]] auto is_vertex(VertexType && t_vertex_candidate) const->bool
    {
      return m_triangulation.get_delaunay().is_vertex(
          std::forward<VertexType>(t_vertex_candidate));
    }  // is_vertex

    /// @brief Forwarding to FoliatedTriangulation_3.is_edge()
    /// @param t_edge_candidate The edge to test
    /// @return True if the candidate is an edge
    [[nodiscard]] auto is_edge(Edge_handle_t<3> const& t_edge_candidate)
        const noexcept -> bool
    {
      return m_triangulation.get_delaunay().tds().is_edge(
          t_edge_candidate.first, t_edge_candidate.second,
          t_edge_candidate.third);
    }  // is_edge

    /// @return Run-time dimensionality of the triangulation data structure
    [[nodiscard]] auto dimensionality() const
    {
      return m_triangulation.dimension();
    }

    /// @brief Initial radius of the first timeslice
    [[nodiscard]] auto initial_radius() const
    {
      return m_triangulation.initial_radius();
    }

    /// @brief Radial separation between timeslices
    [[nodiscard]] auto foliation_spacing() const
    {
      return m_triangulation.foliation_spacing();
    }

    /// @return Number of 3D simplices in geometry data structure
    [[nodiscard]] auto N3() const { return m_geometry.N3; }

    /// @return Number of (3,1) simplices in geometry data structure
    [[nodiscard]] auto N3_31() const { return m_geometry.N3_31; }

    /// @return Number of (2,2) simplices in geometry data structure
    [[nodiscard]] auto N3_22() const { return m_geometry.N3_22; }

    /// @return Number of (1,3) simplices in geometry data structure
    [[nodiscard]] auto N3_13() const { return m_geometry.N3_13; }

    /// @return Number of (3,1) and (1,3) simplices in geometry data structure
    [[nodiscard]] auto N3_31_13() const { return m_geometry.N3_31_13; }

    /// @return Number of 3D simplices in triangulation data structure
    [[nodiscard]] auto simplices() const
    {
      return static_cast<Int_precision>(m_triangulation.get_cells().size());
    }  // number_of_simplices

    /// @return Number of 2D faces in geometry data structure
    [[nodiscard]] auto N2() const { return m_geometry.N2; }

    /// @return An associative container of spacelike faces indexed by timevalue
    [[nodiscard]] auto N2_SL() const->auto const&
    {
      return m_triangulation.N2_SL();
    }  // N2_SL

    /// @return Number of 2D faces in triangulation data structure
    [[nodiscard]] auto faces() const
    {
      return static_cast<Int_precision>(
          m_triangulation.number_of_finite_facets());
    }  // faces

    /// @return Number of 1D edges in geometry data structure
    [[nodiscard]] auto N1() const { return m_geometry.N1; }

    /// @return Number of spacelike edges in triangulation data structure
    [[nodiscard]] auto N1_SL() const { return m_triangulation.N1_SL(); }

    /// @return Number of timelike edges in triangulation data structure
    [[nodiscard]] auto N1_TL() const { return m_triangulation.N1_TL(); }

    /// @return Number of 1D edges in triangulation data structure
    [[nodiscard]] auto edges() const
    {
      return static_cast<Int_precision>(
          m_triangulation.number_of_finite_edges());
    }  // edges

    /// @return Number of vertices in geometry data structure
    [[nodiscard]] auto N0() const { return m_geometry.N0; }

    /// @return Number of vertices in triangulation data structure
    [[nodiscard]] auto vertices() const
    {
      return static_cast<Int_precision>(m_triangulation.number_of_vertices());
    }  // vertices

    /// @return Minimum timeslice value in triangulation data structure
    [[nodiscard]] auto min_time() const
    {
      return m_triangulation.min_time();
    }  // min_time

    /// @return Maximum timeslice value in triangulation data structure
    [[nodiscard]] auto max_time() const
    {
      return m_triangulation.max_time();
    }  // max_time

    /// @brief Perfect forwarding to FoliatedTriangulation_3.degree()
    template <typename VertexHandle>
    [[nodiscard]] auto degree(VertexHandle && t_vertex) const->decltype(auto)
    {
      return m_triangulation.degree(std::forward<VertexHandle>(t_vertex));
    }  // degree

    /// @brief Perfect forwarding to FoliatedTriangulation_3.incident_cells()
    template <typename... Ts>
    [[nodiscard]] auto incident_cells(Ts && ... args) const noexcept
        -> decltype(auto)
    {
      return m_triangulation.incident_cells(std::forward<Ts>(args)...);
    }  // incident_cells

    /// @brief Call to triangulation_.get_timelike_edges()
    [[nodiscard]] auto get_timelike_edges() const noexcept -> auto const&
    {
      return m_triangulation.get_timelike_edges();
    }  // get_timelike_edges

    /// @brief Call triangulation.get_spacelike_edges()
    [[nodiscard]] auto get_spacelike_edges() const->auto const&
    {
      return m_triangulation.get_spacelike_edges();
    }  // get_spacelike_edges

    /// @brief Call FoliatedTriangulation_3.get_vertices()
    [[nodiscard]] auto get_vertices() const noexcept -> auto const&
    {
      return m_triangulation.get_vertices();
    }  // get_vertices

    /// @return True if all cells in triangulation are classified and match
    /// number in geometry
    [[nodiscard]] auto check_simplices() const->bool
    {
      return (this->simplices() == this->N3() &&
              m_triangulation.check_all_cells());
    }  // check_simplices

    /// @brief Print the codimension 1 volume of simplices (faces) per timeslice
    void print_volume_per_timeslice() const
    {
      m_triangulation.print_volume_per_timeslice();
    }  // print_volume_per_timeslice

    /// @brief Print values of a vertex->info()
    void print_vertices() const { m_triangulation.print_vertices(); }

    /// @brief Print timevalues of each vertex in the cell and the resulting
    /// cell->info()
    void print_cells() const { m_triangulation.print_cells(); }

    /// @brief Print manifold
    void print() const
    try
    {
      fmt::print(
          "Manifold has {} vertices and {} edges and {} faces and {} "
          "simplices.\n",
          this->N0(), this->N1(), this->N2(), this->N3());
    }
    catch (...)
    {
      fmt::print(stderr, "print() went wrong ...\n");
      throw;
    }  // print

    /// @brief Print details of the manifold
    void print_details() const
    try
    {
      fmt::print(
          "There are {} (3,1) simplices and {} (2,2) simplices and {} (1,3) "
          "simplices.\n",
          this->N3_31(), this->N3_22(), this->N3_13());
      fmt::print("There are {} timelike edges and {} spacelike edges.\n",
                 this->N1_TL(), this->N1_SL());
    }
    catch (...)
    {
      fmt::print(stderr, "print_details() went wrong ...\n");
      throw;
    }  // print_details

   private:
    /// @brief Update the triangulation
    void update_triangulation()
    try
    {
#ifndef NDEBUG
      spdlog::debug("{} called.\n", __PRETTY_FUNCTION__);
#endif
      Triangulation const local_triangulation(m_triangulation.get_delaunay());
      m_triangulation = local_triangulation;
    }
    catch (std::system_error const& ex)
    {
      fmt::print("Exception thrown: {}\n", ex.what());
    }  // update_triangulation

    /// @brief Update geometry data of the manifold when the triangulation has
    /// been changed
    void update_geometry() noexcept
    {
#ifndef NDEBUG
      spdlog::debug("{} called.\n", __PRETTY_FUNCTION__);
#endif
      Geometry geom(m_triangulation);
      swap(geom, m_geometry);
    }  // update_geometry
  };

  using Manifold_3 = Manifold<3>;

  /// 4D Manifold
  template <>
  class [[nodiscard("This contains data!")]] Manifold<4>
  {
    /// @brief The data structure of scalar values for computations
    Geometry_4 m_geometry;

   public:
    /// @brief Dimensionality of the manifold
    /// @details Used to determine the manifold dimension at compile-time
    static int constexpr dimension = 4;
  };

  using Manifold_4 = Manifold<4>;

}  // namespace manifolds

#endif  // CDT_PLUSPLUS_MANIFOLD_HPP


text:
@interface A0CredentialFieldView : UIView

@property (weak, nonatomic) IBOutlet UITextField *textField;
@property (weak, nonatomic) IBOutlet UIImageView *iconImageView;
@property (assign, nonatomic) BOOL invalid;

@end


text:
describe('<VotingScreen />', () => {
  it('Expect to have unit tests specified', () => {
    expect(true).toEqual(false)
  })
})


text:
'''
This file defines the functions that check Models to their
Meta-Meta-Model.
'''

__author__ = 'William Emfinger'
__copyright__ = 'Copyright 2016, ROSMOD'
__credits__ = ['William Emfinger', 'Pranav Srinivas Kumar']
__license__ = 'GPL'
__version__ = '0.4'
__maintainer__ = 'William Emfinger'
__email__ = 'emfinger@isis.vanderbilt.edu'
__status__ = 'Production'

import meta

def checkModelToMeta(root, meta_dict):
    test = False not in [
        checkObjectToMeta(c, meta_dict)
        for c in root
    ]
    return test

def checkChildrenToMeta(model_dict, meta_dict):
    meta_type = meta_dict[model_dict['Type']]
    meta_name = meta_type['Attributes']['Name']['Value']
    allowed_kids = [
        c['Attributes']['Name']['Value']
        for c in meta_type['Children']
        if 'Cardinality' in c['Attributes']
    ]
    cardinality = {
        c['Attributes']['Name']['Value']:
        c['Attributes']['Cardinality']['Value']
        for c in meta_type['Children']
        if 'Cardinality' in c['Attributes']
    }
    for c in model_dict['Children']:
        # make sure the child type exists in the meta-model
        if not checkObjectToMeta(c, meta_dict):
            print 'ERROR: Child type \'{}\' of {} not in meta-model!'.format(
                c['Type'],
                meta_name
            )
            return False
        child_meta_type = meta_dict[c['Type']]
        child_meta_name = child_meta_type['Attributes']['Name']['Value']
        # make sure the child type is allowed
        if child_meta_name not in allowed_kids:
            print 'ERROR: Child \'{}\' not allowed in {}!'.format(
                child_meta_name,
                meta_name
            )
            print '\tAllowed Children:\n\t\t{}'.format(allowed_kids)
            return False
    # make sure the parent is allowed to have this many kids of this type
    child_types = [
        meta_dict[c['Type']]['Attributes']['Name']['Value']
        for c in model_dict['Children']
    ]
    for kid_type in allowed_kids:
        min_num, max_num = meta.getMinMaxCardinality(
            cardinality[kid_type]
        )
        actual = child_types.count(kid_type)
        if actual < min_num:
            print 'ERROR: must have {} children of type \'{}\' in {}'.format(
                min_num,
                kid_type,
                meta_name
            )
            return False
        if max_num > 0 and actual > max_num:
            print 'ERROR: can only have {} children of type \'{}\' in {}'.format(
                max_num,
                kid_type,
                meta_name
            )
            return False
    return True

def checkPointersToMeta(model_dict, meta_dict):
    meta_type = meta_dict[model_dict['Type']]
    meta_name = meta_type['Attributes']['Name']['Value']
    allowed_ptrs = [
        p['Attributes']['Name']['Value']
        for p in meta_type['Children']
        if p['Type'] == 'MetaPointer'
    ]
    for p in model_dict['Pointers']:
        # make sure the child type exists in the meta-model
        if not checkObjectToMeta(p, meta_dict):
            print 'ERROR: Pointer \'{}\' of {} not in meta-model!'.format(
                p['Type'],
                meta_name
            )
            return False
        ptr_meta_type = meta_dict[p['Type']]
        ptr_meta_name = ptr_meta_type['Attributes']['Name']['Value']
        # make sure the child type is allowed
        if ptr_meta_name not in allowed_ptrs:
            print 'ERROR: Pointer type \'{}\' not allowed in {}!'.format(
                ptr_meta_name,
                meta_name
            )
            print '\tAllowed Pointers:\n\t\t{}'.format(allowed_ptrs)
            return False
    return True

def checkAttributesToMeta(model_dict, meta_dict):
    meta_type = meta_dict[model_dict['Type']]
    meta_name = meta_type['Attributes']['Name']['Value']

    allowed_attr = [
        a['Attributes']['Name']['Value']
        for a in meta_type['Children']
        if a['Type'] == 'MetaAttribute'
    ]

    for a in model_dict['Attributes']:
        if not checkObjectToMeta(a, meta_dict):
            print 'ERROR: Attribute \'{}\' of {} not in meta-model!'.format(
                a['Type'],
                meta_name
            )
            return False
        attr_meta_type = meta_dict[a['Type']]
        attr_meta_name = attr_meta_type['Attribute']['Name']['Value']
        if attr_meta_name not in allowed_attr:
            print 'ERROR: Attribute type \'{}\' not allowed in {}!'.format(
                attr_meta_name,
                meta_name
            )
            print '\tAllowed Attributes:\n\t\t{}'.format(allowed_attr)
            return False

    return True

def checkObjectToMeta(model_dict, meta_dict):
    '''
    This function does a first-level depth check of the validity of a
    model against its meta-model, contained within model_dict and
    meta_dict respectively.
    '''
    # check that it is a valid type
    if model_dict['Type'] not in meta_dict:
        print 'ERROR: object type \'{}\' not in metamodel!'.format(
            model_dict['Type']
        )
        return False

    # check that it has valid children types and numbers (cardinality)
    if 'Children' in model_dict:
        test = checkChildrenToMeta(model_dict, meta_dict)
        if not test:
            return test

    # check that is has valid pointer objects
    if 'Pointers' in model_dict:
        test = checkPointersToMeta(model_dict, meta_dict)
        if not test:
            return test

    # check that is has valid attribute objects
    if 'Attriburtes' in model_dict:
        test = checkAttributesToMeta(model_dict, meta_dict)
        if not test:
            return test
    return True


text:
using System;
using KinderChat.ServiceBusShared.Entities;

namespace KinderChat.WorkerRole.SocketServer.Domain
{
    public interface IInternalMessageBus
    {
        void Send(Event e, string targetInstanceName);

        event Action<Event> EventReceived;
    }
}


text:
package net.sf.jasperreports.crosstabs.fill.calculation;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;

import net.sf.jasperreports.crosstabs.fill.BucketOrderer;
import net.sf.jasperreports.crosstabs.fill.calculation.BucketDefinition.Bucket;
import net.sf.jasperreports.crosstabs.fill.calculation.BucketValueOrderDecorator.OrderPosition;
import net.sf.jasperreports.crosstabs.fill.calculation.MeasureDefinition.MeasureValue;
import net.sf.jasperreports.crosstabs.type.CrosstabTotalPositionEnum;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRRuntimeException;

/**
 * @author Lucian Chirita (lucianc@users.sourceforge.net)
 * @version $Id: CrosstabBucketingService.java 7199 2014-08-27 13:58:10Z teodord $
 */
public class CrosstabBucketingService extends BucketingService implements BucketingData
{

	protected HeaderCell[][] colHeaders;
	protected HeaderCell[][] rowHeaders;
	protected CrosstabCell[][] cells;

	public CrosstabBucketingService(BucketingServiceContext serviceContext,
			List<BucketDefinition> rowBuckets,
			List<BucketDefinition> columnBuckets,
			List<MeasureDefinition> measures,
			boolean sorted, boolean[][] retrieveTotal)
	{
		super(serviceContext, rowBuckets, columnBuckets, measures,
				sorted, retrieveTotal);
	}

	public void createCrosstab() throws JRException
	{
		if (!processed)
		{
			throw new JRRuntimeException("Crosstab data needs to be processed first");
		}

		if (!hasData())
		{
			// nothing to do
			return;
		}

		CollectedList[] collectedHeaders = new CollectedList[BucketingService.DIMENSIONS];
		collectedHeaders[DIMENSION_ROW] = createHeadersList(DIMENSION_ROW, bucketValueMap, 0, false);

		BucketMap columnTotalsMap = null;
		if (allBuckets[0].computeTotal())
		{
			columnTotalsMap = bucketValueMap;
			for (int i = 0; i < rowBucketCount; ++i)
			{
				columnTotalsMap = (BucketMap) columnTotalsMap.getTotalEntry().getValue();
			}
		}

		collectedHeaders[DIMENSION_COLUMN] = createHeadersList(DIMENSION_COLUMN, columnBucketMap, 0, false);

		int rowBuckets = collectedHeaders[BucketingService.DIMENSION_ROW].span;
		int colBuckets = collectedHeaders[BucketingService.DIMENSION_COLUMN].span;

		int bucketMeasureCount = rowBuckets * colBuckets * origMeasureCount;
		checkBucketMeasureCount(bucketMeasureCount);

		colHeaders = createHeaders(BucketingService.DIMENSION_COLUMN, collectedHeaders, columnTotalsMap);
		rowHeaders = createHeaders(BucketingService.DIMENSION_ROW, collectedHeaders, bucketValueMap);

		cells = new CrosstabCell[rowBuckets][colBuckets];
		fillCells(collectedHeaders, bucketValueMap, 0, new int[]{0, 0}, new ArrayList<Bucket>(), new ArrayList<BucketMap>());
	}

	protected HeaderCell[][] createHeaders(byte dimension, CollectedList[] headersLists, BucketMap totalsMap)
	{
		HeaderCell[][] headers = new HeaderCell[buckets[dimension].length][headersLists[dimension].span];

		List<Bucket> vals = new ArrayList<Bucket>();
		fillHeaders(dimension, headers, 0, 0, headersLists[dimension], vals, totalsMap);

		return headers;
	}

	protected CollectedList createHeadersList(byte dimension, BucketMap bucketMap, int level, boolean total)
			throws JRException
	{
		BucketDefinition bucketDefinition = allBuckets[bucketMap.level];
		CrosstabTotalPositionEnum totalPosition = bucketDefinition.getTotalPosition();

		BucketOrderer bucketOrderer = bucketDefinition.getOrderer();
		CollectedList headers;
		if (bucketOrderer != null)
		{
			headers = new OrderedCollectedList(bucketDefinition);
			bucketOrderer.init(this);
		}
		else
		{
			headers = new SequentialCollectedList(totalPosition);
		}

		for (Iterator<Map.Entry<Bucket, Object>> it = bucketMap.entryIterator(); it.hasNext();)
		{
			Map.Entry<Bucket, Object> entry = it.next();
			Bucket bucketValue = entry.getKey();

			boolean totalBucket = bucketValue.isTotal();
			boolean createHeader = !totalBucket || total || totalPosition != CrosstabTotalPositionEnum.NONE;

			if (createHeader)
			{
				CollectedList nextHeaders;
				if (level + 1 < buckets[dimension].length)
				{
					BucketMap nextMap = (BucketMap) entry.getValue();
					nextHeaders = createHeadersList(dimension, nextMap, level + 1, total || totalBucket);
				}
				else
				{
					nextHeaders = new SequentialCollectedList(CrosstabTotalPositionEnum.NONE);
					nextHeaders.span = 1;
				}
				nextHeaders.key = bucketValue;
				if (bucketOrderer != null)
				{
					Object orderValue = bucketOrderer.getOrderValue(bucketMap, bucketValue);
					nextHeaders.orderValue = orderValue;
				}
				headers.add(nextHeaders);
			}
		}

		if (headers.span == 0)
		{
			headers.span = 1;
		}

		return headers;
	}

	public MeasureValue[] getMeasureTotals(BucketMap bucketMap, Bucket bucket)
	{
		Object bucketValue = bucketMap.get(bucket);
		for (int idx = bucketMap.level + 1; idx < rowBucketCount + colBucketCount; ++idx)
		{
			bucketValue = ((BucketMap) bucketValue).getTotalEntry().getValue();
		}
		MeasureValue[] totals = (MeasureValue[]) bucketValue;

		MeasureValue[] userTotals = getUserMeasureValues(totals);
		return userTotals;
	}

	protected void fillHeaders(byte dimension, HeaderCell[][] headers, int level, int col, CollectedList list,
			List<Bucket> vals, BucketMap totalsMap)
	{
		if (level == buckets[dimension].length)
		{
			return;
		}

		for (Iterator<CollectedList> it = list.iterator(); it.hasNext();)
		{
			CollectedList subList = it.next();

			vals.add(subList.key);

			int depthSpan = subList.key.isTotal() ? buckets[dimension].length - level : 1;
			Bucket[] values = new Bucket[buckets[dimension].length];
			vals.toArray(values);

			MeasureValue[][] totals = retrieveHeaderTotals(dimension, values, totalsMap);
			headers[level][col] = new HeaderCell(values, subList.span, depthSpan, totals);

			if (!subList.key.isTotal())
			{
				fillHeaders(dimension, headers, level + 1, col, subList, vals, totalsMap);
			}

			col += subList.span;
			vals.remove(vals.size() - 1);
		}
	}

	protected MeasureValue[][] retrieveHeaderTotals(byte dimension, Bucket[] values, BucketMap totalsMap)
	{
		// an array to advance on bucket levels with values and totals
		int levelCount = buckets[dimension].length;
		Object[] levelBuckets = new Object[levelCount + 1];
		levelBuckets[0] = totalsMap;

		for (int idx = 0; idx < levelCount; ++idx)
		{
			// save this as it gets modified
			Object valueBucket = levelBuckets[idx];

			// advance with totals
			for (int lIdx = 0; lIdx <= idx; ++lIdx)
			{
				if (levelBuckets[lIdx] != null)
				{
					MapEntry entry = ((BucketMap) levelBuckets[lIdx]).getTotalEntry();
					levelBuckets[lIdx] = entry == null ? null : entry.getValue();
				}
			}

			// advance with value if it exists, or total otherwise
			if (valueBucket != null)
			{
				if (idx < values.length && values[idx] != null)
				{
					levelBuckets[idx + 1] = ((BucketMap) valueBucket).get(values[idx]);
				}
				else
				{
					// this is the total computed in the previous loop
					levelBuckets[idx + 1] = levelBuckets[idx];
				}
			}
		}

		if (dimension == DIMENSION_ROW)
		{
			// we need to advance through column totals
			for (int idx = 0; idx < colBucketCount; ++idx)
			{
				for (int lIdx = 0; lIdx <= levelCount; ++lIdx)
				{
					if (levelBuckets[lIdx] != null)
					{
						MapEntry entry = ((BucketMap) levelBuckets[lIdx]).getTotalEntry();
						levelBuckets[lIdx] = entry == null ? null : entry.getValue();
					}
				}
			}
		}

		MeasureValue[][] totals = new MeasureValue[levelCount + 1][];
		for (int lIdx = 0; lIdx <= levelCount; ++lIdx)
		{
			MeasureValue[] measureValues = (MeasureValue[]) levelBuckets[lIdx];
			if (measureValues != null)
			{
				totals[lIdx] = getUserMeasureValues(measureValues);
			}
		}
		return totals;
	}

	protected void fillCells(CollectedList[] collectedHeaders, BucketMap bucketMap, int level, int[] pos, List<Bucket> vals, List<BucketMap> bucketMaps)
	{
		bucketMaps.add(bucketMap);

		byte dimension = level < rowBucketCount ? DIMENSION_ROW : DIMENSION_COLUMN;
		boolean last = level == allBuckets.length - 1;

		CollectedList[] nextCollected = null;
		if (!last)
		{
			nextCollected = new CollectedList[DIMENSIONS];
			for (int d = 0; d < DIMENSIONS; ++d)
			{
				if (d != dimension)
				{
					nextCollected[d] = collectedHeaders[d];
				}
			}
		}

		boolean incrementRow = level == buckets[BucketingService.DIMENSION_ROW].length - 1;

		CollectedList collectedList = collectedHeaders[dimension];

		for (Iterator<CollectedList> it = collectedList.iterator(); it.hasNext();)
		{
			CollectedList list = it.next();
			Object bucketValue = bucketMap == null ? null : bucketMap.get(list.key);

			vals.add(list.key);
			if (last)
			{
				fillCell(pos, vals, bucketMaps, (MeasureValue[]) bucketValue);
			}
			else
			{
				nextCollected[dimension] = list;
				BucketMap nextMap = bucketValue == null ? null : (BucketMap) bucketValue;

				fillCells(nextCollected, nextMap, level + 1, pos, vals, bucketMaps);
			}
			vals.remove(vals.size() - 1);

			if (incrementRow)
			{
				++pos[0];
				pos[1] = 0;
			}
		}

		bucketMaps.remove(bucketMaps.size() - 1);
	}

	protected void fillCell(int[] pos, List<Bucket> vals, List<BucketMap> bucketMaps, MeasureValue[] values)
	{
		Iterator<Bucket> valsIt = vals.iterator();
		Bucket[] rowValues = new Bucket[buckets[BucketingService.DIMENSION_ROW].length];
		for (int i = 0; i < rowValues.length; i++)
		{
			rowValues[i] = valsIt.next();
		}

		Bucket[] columnValues = new Bucket[buckets[BucketingService.DIMENSION_COLUMN].length];
		for (int i = 0; i < columnValues.length; i++)
		{
			columnValues[i] = valsIt.next();
		}

		MeasureValue[] measureVals = values == null ? zeroUserMeasureValues : getUserMeasureValues(values);
		MeasureValue[][][] totals = retrieveTotals(vals, bucketMaps);
		cells[pos[0]][pos[1]] = new CrosstabCell(rowValues, columnValues, measureVals, totals);
		++pos[1];
	}

	protected MeasureValue[][][] retrieveTotals(List<Bucket> vals, List<BucketMap> bucketMaps)
	{
		MeasureValue[][][] totals = new MeasureValue[rowBucketCount + 1][colBucketCount + 1][];

		for (int row = rowRetrTotalMax; row >= rowRetrTotalMin; --row)
		{
			if (!rowRetrTotals[row])
			{
				continue;
			}

			BucketMap rowMap = bucketMaps.get(row);
			for (int i = row; rowMap != null && i < rowBucketCount; ++i)
			{
				MapEntry totalEntry = rowMap.getTotalEntry();
				rowMap = totalEntry == null ? null : (BucketMap) totalEntry.getValue();
			}

			for (int col = 0; col <= rowRetrColMax[row]; ++col)
			{
				BucketMap colMap = rowMap;

				if (col < colBucketCount - 1)
				{
					if (row == rowBucketCount)
					{
						rowMap = bucketMaps.get(rowBucketCount + col + 1);
					}
					else if (rowMap != null)
					{
						rowMap = (BucketMap) rowMap.get(vals.get(rowBucketCount + col));
					}
				}

				if (!retrieveTotal[row][col])
				{
					continue;
				}

				for (int i = col + 1; colMap != null && i < colBucketCount; ++i)
				{
					colMap = (BucketMap) colMap.getTotalEntry().getValue();
				}

				if (colMap != null)
				{
					if (col == colBucketCount)
					{
						MeasureValue[] measureValues = (MeasureValue[]) colMap.get(vals.get(rowBucketCount + colBucketCount - 1));
						if (measureValues != null)
						{
							totals[row][col] = getUserMeasureValues(measureValues);
						}
					}
					else
					{
						MapEntry totalEntry = colMap.getTotalEntry();
						if (totalEntry != null)
						{
							MeasureValue[] totalValues = (MeasureValue[]) totalEntry.getValue();
							totals[row][col] = getUserMeasureValues(totalValues);
						}
					}
				}

				if (totals[row][col] == null)
				{
					totals[row][col] = zeroUserMeasureValues;
				}
			}
		}

		return totals;
	}

	/**
	 * Returns the crosstab column headers.
	 *

	 * {@link #processData() processData()} has to be called before this.
	 *
	 * @return the crosstab column headers
	 */
	public HeaderCell[][] getColumnHeaders()
	{
		return colHeaders;
	}

	/**
	 * Returns the crosstab row headers.
	 *

	 * {@link #processData() processData()} has to be called before this.
	 *
	 * @return the crosstab row headers
	 */
	public HeaderCell[][] getRowHeaders()
	{
		return rowHeaders;
	}

	/**
	 * Returns the crosstab data cells.
	 *

	 * {@link #processData() processData()} has to be called before this.
	 *
	 * @return the crosstab data cells
	 */
	public CrosstabCell[][] getCrosstabCells()
	{
		return cells;
	}

	protected static abstract class CollectedList
	{
		int span;
		Bucket key;
		Object orderValue;

		CollectedList()
		{
			span = 0;
		}

		public abstract Iterator<CollectedList> iterator();

		public void add(CollectedList sublist)
		{
			addSublist(sublist);
			incrementSpan(sublist);
		}

		protected abstract void addSublist(CollectedList sublist);

		private void incrementSpan(CollectedList sublist)
		{
			if (sublist != null)
			{
				span += sublist.span;
			}
			else
			{
				span += 1;
			}
		}

		public String toString()
		{
			return key + "/" + span + ": " + super.toString();
		}
	}

	protected static class SequentialCollectedList extends CollectedList
	{
		final CrosstabTotalPositionEnum totalPosition;
		final LinkedList<CollectedList> list;

		SequentialCollectedList(CrosstabTotalPositionEnum totalPosition)
		{
			this.totalPosition = totalPosition;

			list = new LinkedList<CollectedList>();
		}

		public Iterator<CollectedList> iterator()
		{
			return list.iterator();
		}

		protected void addSublist(CollectedList sublist)
		{
			if (sublist.key.isTotal() && totalPosition == CrosstabTotalPositionEnum.START)
			{
				list.addFirst(sublist);
			}
			else
			{
				list.add(sublist);
			}
		}
	}

	protected static class OrderedCollectedList extends CollectedList
	{
		final TreeSet<CollectedList> list;

		OrderedCollectedList(BucketDefinition bucketDefinition)
		{
			super();

			CollectedListComparator comparator =
				new CollectedListComparator(bucketDefinition);
			list = new TreeSet<CollectedList>(comparator);
		}

		public Iterator<CollectedList> iterator()
		{
			return list.iterator();
		}

		protected void addSublist(CollectedList sublist)
		{
			list.add(sublist);
		}
	}

	protected static class CollectedListComparator implements Comparator<CollectedList>
	{
		final BucketOrderer bucketOrderer;
		final boolean totalFirst;

		CollectedListComparator(BucketDefinition bucketDefinition)
		{
			this.bucketOrderer = bucketDefinition.getOrderer();
			this.totalFirst = bucketDefinition.getTotalPosition()
					== CrosstabTotalPositionEnum.START;
		}

		public int compare(CollectedList l1, CollectedList l2)
		{
			if (l1 == l2)
			{
				return 0;
			}

			int order;
			if (l1.key.isTotal())
			{
				if (l2.key.isTotal())
				{
					// this should not happen
					throw new JRRuntimeException("Two total keys in the same list");
				}

				order = totalFirst ? -1 : 1;
			}
			else if (l2.key.isTotal())
			{
				order = totalFirst ? 1 : -1;
			}
			else
			{
				// check order positions
				OrderPosition orderPosition1 = l1.key.getOrderPosition();
				OrderPosition orderPosition2 = l2.key.getOrderPosition();
				if (orderPosition1 != orderPosition2)
				{
					order = orderPosition1.comparePosition(orderPosition2);
				}
				else
				{
					// compare the order values
					order = bucketOrderer.compareOrderValues(
							l1.orderValue, l2.orderValue);

					if (order == 0)
					{
						// if order values are equal, fallback to bucket value order
						order = l1.key.compareTo(l2.key);
					}
				}
			}

			return order;
		}
	}

	@Override
	public BucketingServiceContext getServiceContext()
	{
		return serviceContext;
	}

	@Override
	public Bucket getColumnTotalBucket(int columnGroupIndex)
	{
		if (columnGroupIndex < 0 || columnGroupIndex >= colBucketCount)
		{
			throw new IndexOutOfBoundsException("Column group index " + columnGroupIndex
					+ " out of range, column group count is " + colBucketCount);
		}

		return allBuckets[rowBucketCount + columnGroupIndex].VALUE_TOTAL;
	}

	@Override
	public Bucket getColumnBucket(int columnGroupIndex, Object value)
	{
		if (columnGroupIndex < 0 || columnGroupIndex >= colBucketCount)
		{
			throw new IndexOutOfBoundsException("Column group index " + columnGroupIndex
					+ " out of range, column group count is " + colBucketCount);
		}

		BucketDefinition bucket = allBuckets[rowBucketCount + columnGroupIndex];
		return value == null ? bucket.VALUE_NULL : bucket.create(value);
	}

	@Override
	public MeasureValue[] getMeasureValues(BucketMap bucketMap, Bucket bucket,
			List<Bucket> columnValues)
	{
		Object bucketValue = bucketMap.get(bucket);
		// advance to row totals
		for (int idx = bucketMap.level + 1; idx < rowBucketCount; ++idx)
		{
			bucketValue = ((BucketMap) bucketValue).getTotalEntry().getValue();
		}

		// advance to column values
		Iterator<Bucket> colValuesIt = columnValues.iterator();
		for (int idx = 0; idx < colBucketCount && bucketValue != null; ++idx)
		{
			if (colValuesIt.hasNext())
			{
				Bucket columnBucket = colValuesIt.next();
				bucketValue = ((BucketMap) bucketValue).get(columnBucket);
			}
			else
			{
				// if we don't have a value for the column group, use the total
				bucketValue = ((BucketMap) bucketValue).getTotalEntry().getValue();
			}
		}

		MeasureValue[] measureValues;
		if (bucketValue == null)
		{
			// the column values were not present for the row, using zero values
			measureValues = zeroUserMeasureValues;
		}
		else
		{
			measureValues = getUserMeasureValues((MeasureValue[]) bucketValue);
		}
		return measureValues;
	}

}


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

namespace AspNetCore
{
    public class SanitizeIM
    {
        public string Html { get; set; }
    }

    public class SanitizeVM : BaseVM
    {
        public SanitizeIM Input { get; set; }
        public string SanitizedHtml { get; set; }
        public string Text { get; set; }

        public SanitizeVM(SanitizeIM input) : base(null)
        {
            Input = input;
        }

    }

}


text:
module Gouge
  module Notification
    extend ::ActiveSupport::Concern

    included do
      after_initialize :initialize_notification
      attr_reader :notifications
    end

    def initialize_notification
      @notifications = {
        success: ::ActiveModel::Errors.new(self),
        warning: ::ActiveModel::Errors.new(self),
        info: ::ActiveModel::Errors.new(self)
      }
    end

    module ClassMethods
      # nop
    end
  end
end


text:
package org.apache.calcite.sql.ddl;

import org.apache.calcite.sql.SqlIdentifier;
import org.apache.calcite.sql.SqlKind;
import org.apache.calcite.sql.SqlOperator;
import org.apache.calcite.sql.SqlSpecialOperator;
import org.apache.calcite.sql.parser.SqlParserPos;

/**
 * Parse tree for {@code DROP TYPE} statement.
 */
public class SqlDropType extends SqlDropObject {
  private static final SqlOperator OPERATOR =
      new SqlSpecialOperator("DROP TYPE", SqlKind.DROP_TYPE);

  SqlDropType(SqlParserPos pos, boolean ifExists, SqlIdentifier name) {
    super(OPERATOR, pos, ifExists, name);
  }
}

// End SqlDropType.java


text:
package com.sequenceiq.freeipa.controller.mapper;

import javax.ws.rs.core.Response.Status;

import org.springframework.stereotype.Component;

import com.sequenceiq.cloudbreak.exception.mapper.BaseExceptionMapper;

@Component
public class IllegalStateExceptionMapper extends BaseExceptionMapper<IllegalStateException> {

    @Override
    public Status getResponseStatus(IllegalStateException exception) {
        return Status.BAD_REQUEST;
    }

    @Override
    public Class<IllegalStateException> getExceptionType() {
        return IllegalStateException.class;
    }
}


text:
package org.apache.geode.test.dunit;

import static org.apache.geode.test.dunit.Invoke.invokeInEveryVM;

import org.apache.geode.admin.internal.AdminDistributedSystemImpl;
import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.internal.cache.GemFireCacheImpl;

public class Disconnect {

  public static void disconnectAllFromDS() {
    disconnectFromDS();
    invokeInEveryVM("disconnectFromDS", () -> disconnectFromDS());
  }

  /**
   * Disconnects this VM from the distributed system
   */
  public static void disconnectFromDS() {
    GemFireCacheImpl.testCacheXml = null;

    for (;;) {
      DistributedSystem ds = InternalDistributedSystem.getConnectedInstance();
      if (ds == null) {
        break;
      }
      try {
        ds.disconnect();
      } catch (Exception ignore) {
      }
    }

    AdminDistributedSystemImpl ads = AdminDistributedSystemImpl.getConnectedInstance();
    if (ads != null) {
      ads.disconnect();
    }
  }
}


text:
module Mutant
  class Mutator
    class Node
      # Emitter for perl style match current line node
      class MatchCurrentLine < self

        handle :match_current_line

        children :regexp

      private

        # Emit mutants
        #
        # @return [undefined]
        #
        # @api private
        def dispatch
          emit_singletons
          emit_regexp_mutations
        end

      end # MatchCurrentLine
    end # Node
  end # Mutator
end # Mutant


text:
using DragonSpark.Model.Operations;
using DragonSpark.Model.Selection;
using System;
using System.Threading;
using System.Threading.Tasks;

namespace DragonSpark.Compose.Model.Operations;

sealed class TokenAwareSelecting<TIn, TOut> : ISelecting<TIn, TOut>
{
	readonly ISelect<TIn, ValueTask<TOut>> _operation;
	readonly Func<CancellationToken>       _token;

	public TokenAwareSelecting(ISelect<TIn, ValueTask<TOut>> operation, Func<CancellationToken> token)
	{
		_operation = operation;
		_token     = token;
	}

	public async ValueTask<TOut> Get(TIn parameter)
	{
		var token = _token();
		token.ThrowIfCancellationRequested();
		var result = await _operation.Await(parameter);
		token.ThrowIfCancellationRequested();
		return result;
	}
}


text:
---
uid: SolidEdgeFramework.ISEApplicationEvents.BeforeCommandRun(System.Int32)
summary:
remarks:
syntax:
    parameters:
    - id: theCommandID
      description: The ID of the command for which the event is triggered.
---


text:
<Type Name="NSSharingService" FullName="MonoMac.AppKit.NSSharingService">
  <TypeSignature Language="C#" Value="public class NSSharingService : MonoMac.Foundation.NSObject" />
  <TypeSignature Language="ILAsm" Value=".class public auto ansi beforefieldinit NSSharingService extends MonoMac.Foundation.NSObject" />
  <AssemblyInfo>
    <AssemblyName>MonoMac</AssemblyName>
    <AssemblyVersion>0.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <Base>
    <BaseTypeName>MonoMac.Foundation.NSObject</BaseTypeName>
  </Base>
  <Interfaces />
  <Attributes>
    <Attribute>
      <AttributeName>MonoMac.Foundation.Register("NSSharingService", true)</AttributeName>
    </Attribute>
    <Attribute>
      <AttributeName>MonoMac.ObjCRuntime.MountainLion</AttributeName>
    </Attribute>
  </Attributes>
  <Docs>
    To be added.
    <remarks>To be added.</remarks>
  </Docs>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSSharingService ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor() cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("init")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters />
      <Docs>
        To be added.
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSSharingService (MonoMac.Foundation.NSCoder coder);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(class MonoMac.Foundation.NSCoder coder) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("initWithCoder:")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="coder" Type="MonoMac.Foundation.NSCoder" />
      </Parameters>
      <Docs>
        <param name="coder">The unarchiver object.</param>
        A constructor that initializes the object from the data stored in the unarchiver object.
        <remarks>This constructor is provided to allow the class to be initialized from an unarchiver (for example, during NIB deserialization).</remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSSharingService (MonoMac.Foundation.NSObjectFlag t);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(class MonoMac.Foundation.NSObjectFlag t) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="t" Type="MonoMac.Foundation.NSObjectFlag" />
      </Parameters>
      <Docs>
        <param name="t">Unused sentinel value, pass NSObjectFlag.Empty.</param>
        Constructor to call on derived classes when the derived class has an [Export] constructor.
        <remarks>
          <para>This constructor should be called by derived classes when they are initialized using an [Export] attribute. The argument value is ignore, typically the chaining would look like this:</para>
          <example>

public class MyClass : BaseClass {
    [Export ("initWithFoo:")]
    public MyClass (string foo) : base (NSObjectFlag.Empty)
    {
        ...
    }

          </example>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSSharingService (IntPtr handle);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(native int handle) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="handle" Type="System.IntPtr" />
      </Parameters>
      <Docs>
        <param name="handle">Pointer (handle) to the unmanaged object.</param>
        A constructor used when creating managed representations of unmanaged objects;  Called by the runtime.
        <remarks>
          <para>This constructor is invoked by the runtime infrastructure (<see cref="M:MonoMac.ObjCRuntime.GetNSObject (System.IntPtr)" />) to create a new managed representation for a pointer to an unmanaged Objective-C object.    You should not invoke this method directly, instead you should call the GetNSObject method as it will prevent two instances of a managed object to point to the same native object.</para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSSharingService (string title, MonoMac.AppKit.NSImage image, MonoMac.AppKit.NSImage alternateImage, MonoMac.AppKit.NSSharingServiceHandler handler);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(string title, class MonoMac.AppKit.NSImage image, class MonoMac.AppKit.NSImage alternateImage, class MonoMac.AppKit.NSSharingServiceHandler handler) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("initWithTitle:image:alternateImage:handler:")</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="title" Type="System.String" />
        <Parameter Name="image" Type="MonoMac.AppKit.NSImage" />
        <Parameter Name="alternateImage" Type="MonoMac.AppKit.NSImage" />
        <Parameter Name="handler" Type="MonoMac.AppKit.NSSharingServiceHandler" />
      </Parameters>
      <Docs>
        <param name="title">To be added.</param>
        <param name="image">To be added.</param>
        <param name="alternateImage">To be added.</param>
        <param name="handler">To be added.</param>
        To be added.
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="AlternateImage">
      <MemberSignature Language="C#" Value="public virtual MonoMac.AppKit.NSImage AlternateImage { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class MonoMac.AppKit.NSImage AlternateImage" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>get: MonoMac.Foundation.Export("alternateImage")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSImage</ReturnType>
      </ReturnValue>
      <Docs>
        To be added.
        <value>To be added.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="CanPerformWithItems">
      <MemberSignature Language="C#" Value="public virtual bool CanPerformWithItems (MonoMac.Foundation.NSObject[] items);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance bool CanPerformWithItems(class MonoMac.Foundation.NSObject[] items) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("canPerformWithItems:")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="items" Type="MonoMac.Foundation.NSObject[]" />
      </Parameters>
      <Docs>
        <param name="items">To be added.</param>
        To be added.
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="ClassHandle">
      <MemberSignature Language="C#" Value="public override IntPtr ClassHandle { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance native int ClassHandle" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.IntPtr</ReturnType>
      </ReturnValue>
      <Docs>
        The handle for this class.
        <value>The pointer to the Objective-C class.</value>
        <remarks>Each MonoMac class mirrors an unmanaged Objective-C class.   This value contains the pointer to the Objective-C class, it is similar to calling objc_getClass with the object name.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Delegate">
      <MemberSignature Language="C#" Value="public MonoMac.AppKit.NSSharingServiceDelegate Delegate { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class MonoMac.AppKit.NSSharingServiceDelegate Delegate" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSSharingServiceDelegate</ReturnType>
      </ReturnValue>
      <Docs>
        An instance of the MonoMac.AppKit.NSSharingServiceDelegate model class which acts as the class delegate.
        <value>
          <para>The instance of the MonoMac.AppKit.NSSharingServiceDelegate model class</para>
          <para tool="nullallowed">This value can be <see langword="null" />.</para>
        </value>
        <remarks>
          <para>The delegate instance assigned to this object will be used to handle events or provide data on demand to this class.</para>
          <para>When setting the Delegate or WeakDelegate values events will be delivered to the specified instance instead of being delivered to the C#-style events</para>
          <para>This is the strongly typed version of the object, use the WeakDelegate property instead if you want to merely assign a class derived from NSObject that has been decorated with [Export] attributes.</para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="DidFailToShareItems">
      <MemberSignature Language="C#" Value="public event EventHandler<MonoMac.AppKit.NSSharingServiceDidFailToShareItemsEventArgs> DidFailToShareItems;" />
      <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class MonoMac.AppKit.NSSharingServiceDidFailToShareItemsEventArgs> DidFailToShareItems" />
      <MemberType>Event</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.EventHandler<MonoMac.AppKit.NSSharingServiceDidFailToShareItemsEventArgs></ReturnType>
      </ReturnValue>
      <Docs>
        Event raised by the object.
        <remarks>If you assign a value to this event, this will reset the value for the WeakDelegate property to an internal handler that maps delegates to events.</remarks>
      </Docs>
    </Member>
    <Member MemberName="DidShareItems">
      <MemberSignature Language="C#" Value="public event EventHandler<MonoMac.AppKit.NSSharingServiceItemsEventArgs> DidShareItems;" />
      <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class MonoMac.AppKit.NSSharingServiceItemsEventArgs> DidShareItems" />
      <MemberType>Event</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.EventHandler<MonoMac.AppKit.NSSharingServiceItemsEventArgs></ReturnType>
      </ReturnValue>
      <Docs>
        Event raised by the object.
        <remarks>If you assign a value to this event, this will reset the value for the WeakDelegate property to an internal handler that maps delegates to events.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Dispose">
      <MemberSignature Language="C#" Value="protected override void Dispose (bool disposing);" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance void Dispose(bool disposing) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="disposing" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="disposing">
          <para>If set to <see langword="true" />, the method is invoked directly and will dispose manage and unmanaged resources;   If set to <see langword="false" /> the method is being called by the garbage collector finalizer and should only release unmanaged resources.</para>
        </param>
        Releases the resources used by the NSSharingService object.
        <remarks>
          <para>This Dispose method releases the resources used by the NSSharingService class.</para>
          <para>This method is called by both the Dispose() method and the object finalizer (Finalize).    When invoked by the Dispose method, the parameter disposting <paramref name="disposing" /> is set to <see langword="true" /> and any managed object references that this object holds are also disposed or released;  when invoked by the object finalizer, on the finalizer thread the value is set to <see langword="false" />. </para>
          <para>Calling the Dispose method when you are finished using the NSSharingService ensures that all external resources used by this managed object are released as soon as possible.  Once you have invoked the Dispose method, the object is no longer useful and you should no longer make any calls to it.</para>
          <para>  For more information on how to override this method and on the Dispose/IDisposable pattern, read the ``Implementing a Dispose Method'' document at http://msdn.microsoft.com/en-us/library/fs2xkftw.aspx</para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="GetSharingService">
      <MemberSignature Language="C#" Value="public static MonoMac.AppKit.NSSharingService GetSharingService (MonoMac.AppKit.NSSharingServiceName service);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig class MonoMac.AppKit.NSSharingService GetSharingService(valuetype MonoMac.AppKit.NSSharingServiceName service) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSSharingService</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="service" Type="MonoMac.AppKit.NSSharingServiceName" />
      </Parameters>
      <Docs>
        <param name="service">To be added.</param>
        To be added.
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="GetSharingService">
      <MemberSignature Language="C#" Value="public static MonoMac.AppKit.NSSharingService GetSharingService (MonoMac.Foundation.NSString serviceName);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig class MonoMac.AppKit.NSSharingService GetSharingService(class MonoMac.Foundation.NSString serviceName) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("sharingServiceNamed:")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSSharingService</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="serviceName" Type="MonoMac.Foundation.NSString" />
      </Parameters>
      <Docs>
        <param name="serviceName">To be added.</param>
        To be added.
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Image">
      <MemberSignature Language="C#" Value="public virtual MonoMac.AppKit.NSImage Image { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class MonoMac.AppKit.NSImage Image" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>get: MonoMac.Foundation.Export("image")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSImage</ReturnType>
      </ReturnValue>
      <Docs>
        To be added.
        <value>To be added.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="PerformWithItems">
      <MemberSignature Language="C#" Value="public virtual void PerformWithItems (MonoMac.Foundation.NSObject[] items);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance void PerformWithItems(class MonoMac.Foundation.NSObject[] items) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("performWithItems:")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="items" Type="MonoMac.Foundation.NSObject[]" />
      </Parameters>
      <Docs>
        <param name="items">To be added.</param>
        To be added.
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="SharingServicesForItems">
      <MemberSignature Language="C#" Value="public static MonoMac.AppKit.NSSharingService[] SharingServicesForItems (MonoMac.Foundation.NSObject[] items);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig class MonoMac.AppKit.NSSharingService[] SharingServicesForItems(class MonoMac.Foundation.NSObject[] items) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("sharingServicesForItems:")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSSharingService[]</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="items" Type="MonoMac.Foundation.NSObject[]" />
      </Parameters>
      <Docs>
        <param name="items">To be added.</param>
        To be added.
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="SourceFrameOnScreenForShareItem">
      <MemberSignature Language="C#" Value="public MonoMac.AppKit.NSSharingServiceSourceFrameOnScreenForShareItem SourceFrameOnScreenForShareItem { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class MonoMac.AppKit.NSSharingServiceSourceFrameOnScreenForShareItem SourceFrameOnScreenForShareItem" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSSharingServiceSourceFrameOnScreenForShareItem</ReturnType>
      </ReturnValue>
      <Docs>
        Delegate invoked by the object to get a value.
        <value>To be added.</value>
        <remarks>You assign a function, delegate or anonymous method to this property to return a value to the object.   If you assign a value to this property, it this will reset the value for the WeakDelegate property to an internal handler that maps delegates to events.</remarks>
      </Docs>
    </Member>
    <Member MemberName="SourceWindowForShareItems">
      <MemberSignature Language="C#" Value="public MonoMac.AppKit.NSSharingServiceSourceWindowForShareItems SourceWindowForShareItems { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class MonoMac.AppKit.NSSharingServiceSourceWindowForShareItems SourceWindowForShareItems" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSSharingServiceSourceWindowForShareItems</ReturnType>
      </ReturnValue>
      <Docs>
        Delegate invoked by the object to get a value.
        <value>To be added.</value>
        <remarks>You assign a function, delegate or anonymous method to this property to return a value to the object.   If you assign a value to this property, it this will reset the value for the WeakDelegate property to an internal handler that maps delegates to events.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Title">
      <MemberSignature Language="C#" Value="public virtual string Title { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string Title" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>get: MonoMac.Foundation.Export("title")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        To be added.
        <value>To be added.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TransitionImageForShareItem">
      <MemberSignature Language="C#" Value="public MonoMac.AppKit.NSSharingServiceTransitionImageForShareItem TransitionImageForShareItem { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class MonoMac.AppKit.NSSharingServiceTransitionImageForShareItem TransitionImageForShareItem" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSSharingServiceTransitionImageForShareItem</ReturnType>
      </ReturnValue>
      <Docs>
        Delegate invoked by the object to get a value.
        <value>To be added.</value>
        <remarks>You assign a function, delegate or anonymous method to this property to return a value to the object.   If you assign a value to this property, it this will reset the value for the WeakDelegate property to an internal handler that maps delegates to events.</remarks>
      </Docs>
    </Member>
    <Member MemberName="WeakDelegate">
      <MemberSignature Language="C#" Value="public virtual MonoMac.Foundation.NSObject WeakDelegate { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class MonoMac.Foundation.NSObject WeakDelegate" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>get: MonoMac.Foundation.Export("delegate")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>set: MonoMac.Foundation.Export("setDelegate:")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>MonoMac.Foundation.NSObject</ReturnType>
      </ReturnValue>
      <Docs>
        An object that can respond to the delegate protocol for this type
        <value>
          <para>The instance that will respond to events and data requests.</para>
          <para tool="nullallowed">This value can be <see langword="null" />.</para>
        </value>
        <remarks>
          <para>The delegate instance assigned to this object will be used to handle events or provide data on demand to this class.</para>
          <para>When setting the Delegate or WeakDelegate values events will be delivered to the specified instance instead of being delivered to the C#-style events</para>
          <para>   Methods must be decorated with the [Export ("selectorName")] attribute to respond to each method from the protocol.   Alternatively use the Delegate method which is strongly typed and does not require the [Export] attributes on methods.</para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="WillShareItems">
      <MemberSignature Language="C#" Value="public event EventHandler<MonoMac.AppKit.NSSharingServiceItemsEventArgs> WillShareItems;" />
      <MemberSignature Language="ILAsm" Value=".event class System.EventHandler`1<class MonoMac.AppKit.NSSharingServiceItemsEventArgs> WillShareItems" />
      <MemberType>Event</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.EventHandler<MonoMac.AppKit.NSSharingServiceItemsEventArgs></ReturnType>
      </ReturnValue>
      <Docs>
        Event raised by the object.
        <remarks>If you assign a value to this event, this will reset the value for the WeakDelegate property to an internal handler that maps delegates to events.</remarks>
      </Docs>
    </Member>
  </Members>
</Type>


text:
.class public interface abstract annotation Ljavax/annotation/OverridingMethodsMustInvokeSuper;
.super Ljava/lang/Object;
.source "OverridingMethodsMustInvokeSuper.java"

# interfaces
.implements Ljava/lang/annotation/Annotation;

# annotations
.annotation runtime Ljava/lang/annotation/Documented;
.end annotation

.annotation runtime Ljava/lang/annotation/Retention;
    value = .enum Ljava/lang/annotation/RetentionPolicy;->RUNTIME:Ljava/lang/annotation/RetentionPolicy;
.end annotation

.annotation runtime Ljava/lang/annotation/Target;
    value = {
        .enum Ljava/lang/annotation/ElementType;->METHOD:Ljava/lang/annotation/ElementType;
    }
.end annotation