text:
<TITLE>Learn How To Learn, Improve or Master Modern English and Any Other Subject Fast!</TITLE>

<META http-equiv=Content-Type content="text/html; charset=windows-1252">

<meta http-equiv="Content-Language" content="en">

<meta name="abstract" content="Learn, Improve or Master English and Any Other Subject Ten Times Faster with SupremeLearning courses">

<meta name="robots" content="FOLLOW,INDEX">

<meta name="revisit-after" content="15 days">

<meta name="description" content="Improve or master your English and Learn How To Learn Any Subject Ten Times Faster with SupremeLearning courses. Learn, improve, or master spoken or written foreign languages, pronunciation, phonetics, accent, spelling, grammar, listening, comprehension, memory -- even typing or speed-reading.">

<meta name="keywords" content="superlearning,supremelearning,accelerated-learning,learn,how,to,rapid,ESL,English,languages,Berlitz,phonetics,courses,pronunciation,teaching,Mavis,accelerated,Beacon,learning,English,ESL,American,faster,superlearning,suggestopedia,neuro-linguistics,foreigners,programming,for,beginners,advanced,adult,learners,improvement,accelerated,English,American,superlearning,supremelearning,intonation,accent,reduction,speech,super,learning,American,accelerated-learning,ESL,a,relaxed-learning,relaxed,TOEFL,languages,Lozanov,memory,mega,accelerative,USA,intensive,grammar,comprehension,listening,reading,writing,spoken,spelling,typing,audio,video,books,software,as,second,speed,techniques,methods,subliminal,message,suggestive,vocabulary,phonics,kevin,training,verbal,advantage,self,skills,immersion,NLP,lazy,easier,mnemonics,suggestive-accelerative,studies,speed-reading">

<LINK href="images/home.css" type="text/css" rel="stylesheet">

ESPANOL

  | CHINESE |

  RUSSIAN

  | UKRAINIAN

  | FRENCH | GERMAN

Home page

Seminar

excerpts

Course ordering via SupremeLearning Store

Course

information

Principal

author

Book

excerpts

Transcript excerpts

Contact

us

 Learn How To Learn,

  Improve or Master English, Russian, Spanish,... Typing (PC Keyboarding) and

  Any Other Subject up to Ten Times More Effectively with SupremeLearning™

  & LearnHowToLearnAndTeachFast™ Courses

  & Seminars,

  developed by Gin I. Paris & World-Renowned Educator, Bestselling Author,

  Guinness and Marvel Book World Champion in Multilingual Instruction & Computer

  Keyboarding, Mr. Michael Shestov

Michael Shestov:

 <justify> "When the

language instructors of even such great countries as US and UK can hardly even

dream of effectively improving any level of language skills of the 'old' and 'new'

Americans and Britons, who is left to help the foreign authors of modern English

self-study manuals and courses, master pronunciation and teach themselves

to speak and write standard English fluently?" [Read

more...] </justify>

 PRINCIPAL

AUTHOR

If it walks like an educator,

 And talks like an educator,

  You can bet it's  NOT  an educator.

Translate

  this page yourself

 TOPICS

  BELOW

Who's Michael Shestov?

Images of principal

  author, Michael Shestov, and one of his Guinness certificates

The supernova -- born

  and developed

M. Shestov in New York

Translate this page yourself

How to contact us or purchase

  courses

WHO'S

  MICHAEL SHESTOV?

 SupremeLearning's founding

  author, MICHAEL SHESTOV, is a:

World-renowned educator, international investigative journalist and syndicated columnist in the field

     of education; linguist-polyglot; advisor to a number of UN organizations,

     and American and Russian governmental agencies with goals of increasing the

     effectivity of the continuing education and the learning process of adults

Scientific leader

     of several charitable and profitable national and international institutions

     interested in conducting research on solving the worldwide problem of how

     to increase the productivity of the interaction between humans and computers

Recognized by U.S.

     and other countries' authorities as having extraordinary abilities in the

     sciences and education

Honorable president

     of "Alma Mater" press association

Member of New York

     Foreign Press Association and New York Press Association

Guinness and Marvel

     Books of World Records keyboarding and teaching phenomenon

Former assistant to

     the Minister of Special and Professional Education (at age 25)

Keyboarding World Champion (first

     becoming so at age 28) by inventing a special system of error-free work in

     any language  [Read about

     Shestov's intellectual achievements.]

Master worker in over 20 languages

Proficient word processor

     on over 40 computer keyboards of the world

Ergonomic analyst

     and consumer advocate

Morse code expert

     and instructor

Master kick-boxer

     and instructor

Self-taught

   classical pianist

IMAGES

  OF PRINCIPAL AUTHOR, MICHAEL SHESTOV, AND ONE OF HIS GUINNESS CERTIFICATES

 Click to see larger image.

THE

   SUPERNOVA -- BORN AND DEVELOPED

 About twenty years ago,

 Shestov devised his first teaching system, which allowed military telegraphists

 to reach professional levels of working within 7 days, instead of the usual 4

 months. The system had a 95 percent success rate, rather than the 40 to 50 percent

 success rate only sometimes reached by the previous system. Shestov subsequently

 discovered how to practically apply the newly formulated pedagogical principles

 of his system to Morse code, native and foreign language improvement, speed reading,

 short and longhand writing, sign language, and other areas -- all of which amazingly

 had the same success rate as the original system used with telegraphists.

The SupremeLearning system can be

   applied to any area involving human movements. SupremeLearning has extraordinary

   impact with those areas that must be performed virtually error-free, so as

   to prevent human and material injuries, as well as financial losses. SupremeLearning's

   success is partly due to its special exercises carefully developed for the

   adult brain, combined with ergonomically correct movements, which quickly generate

   new brain cell connections -- consequently, providing higher quality and more

   stable performances, as well as allowing significantly shorter learning periods.

A main difference between SupremeLearning

   and the traditional -- as well as, ostensibly, accelerated -- methods of teaching

   is Shestov's goals in stressing the importance of teaching slow learning students,

   students with psychological disorders, and people who have failed to learn

   from other courses. SupremeLearning can be applied to children and adults at

   all levels of ability, from beginners all the way to the most advanced -- the

   system's specialty being adults who are seemingly "stuck" at whatever

   level they are currently.

As one example, Shestov

  was designated the world's fastest, most efficient multi-lingual instructor

  by the Marvel book of records, human achievements, and phenomena, after spending

  in 1993 only 7.5 hours (20 times faster than other instructors would have taken),

  to teach 80 children in Denmark to type and spell perfectly in Danish. This

  is especially noteworthy since Danish is not Shestov's native language (he was

  born in Russia). SupremeLearning was subsequently officially endorsed

  by the Danish minister of education as the "best on earth".

M.

  SHESTOV IN NEW YORK

  Michael Shestov and the Founder

  of the United Nations "Earth Day",

  Mr. John McConnell

Michael

Shestov & the Acting Permanent Representative of Germany to the United Nations,

Ambassador Dr. Hanns Schumacher

Michael Shestov

   & The Ambassador of Argentina in the US,

   Mr. Diego Ramiro Guelar

Michael Shestov

   & Eduardo Juarez-Pagliocco, President,
International Immigrants Foundation/International Cultures Mission,
a United Nation NGO-ECOSOC organization

Michael Shestov & the Permanent

Representative of Russian Federation to the United Nations, Ambassador, Mr. Sergei

Lavrov

HOW

  TO CONTACT US OR ORDER COURSES

  When you click below, you will be transferred to the SupremeLearning Online

  Store where you may order SupremeLearning books, videobooks, audiobooks,

  and learning software.

Go

to the SupremeLearning Store

SupremeLearning educational products are published

by Wayward Ventures Publishing.

Our main contact address is:

  Wayward Ventures Publishing

  79 Pine Street #188, New York, NY 10005, USA

Our phone

  numbers are:

  toll-free:  1-800-557-7763, 1-888-259-7401, 1-888-876-2762, 1-800-880-2287 & 1-877-466-7925 (for US residents only),

  1-800-557-7763 (for US & Canada residents only) or

  direct:1-917-208-7434 & 1-917-208-9964;

  fax: 1-253-981-1477

  email: info@supremelearning.com,

  info@learnhowtolearn.com or

  info@learnhowtolearnandteachfast.com

You may send us a request for written information or to make

  an appointment for a phone consultation. Don't forget to give us your name,

  contact phone, the city and the country where you want the courses to be delivered

  and proposed method of payment. Within 3 business days an English speaking administrator

  of WVP will contact you to discuss all possible purchase and delivery options.

Email system or product

  questions to info@supremelearning.com

  or info@learnhowtolearn.com

TRANSLATE

  THIS PAGE YOURSELF

You can translate this page into Italian,

  German, Portuguese, French (use our own site for Spanish,

  Russian or Chinese)

  and, if you have the proper screen fonts, other languages (Japanese, Korean,

  etc.):

  Home page | Course information | Order SL

  courses via SL Store | Principal author | Book excerpts

  | Transcript

  excerpts | Seminar excerpts | Contact us | Limited

  time SL specials |

This page

was last updated January 4th, 2013

© Copyright 1987-2013 by Wayward

Ventures Publishing & Michael Shestov


text:
package org.hibernate.validator.ap.testmodel.groupsequenceprovider;

import java.util.List;

import org.hibernate.validator.ap.testmodel.groupsequenceprovider.GroupSequenceProviderDefinition.FooBarBaz;
import org.hibernate.validator.spi.group.DefaultGroupSequenceProvider;

/**
 * @author Kevin Pollet <kevin.pollet@serli.com> (C) 2011 SERLI
 */
public class FooBarBazDefaultGroupSequenceProvider implements DefaultGroupSequenceProvider<FooBarBaz> {

	public FooBarBazDefaultGroupSequenceProvider(FooBarBaz fooBarBaz) {
	}

	public List<Class<?>> getValidationGroups(FooBarBaz object) {
		return null;
	}
}

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.CodeDom.Compiler;
using System.ComponentModel;
using System.Diagnostics;

namespace Alchemy4Tridion.Plugins.Clients.CoreService
{
	[GeneratedCode("System.ServiceModel", "4.0.0.0"), DebuggerStepThrough]
	public class GetWorkItemSnapshotCompletedEventArgs : AsyncCompletedEventArgs
	{
		private object[] results;

		public RenderedItemData Result
		{
			get
			{
				base.RaiseExceptionIfNecessary();
				return (RenderedItemData)this.results[0];
			}
		}

		public GetWorkItemSnapshotCompletedEventArgs(object[] results, Exception exception, bool cancelled, object userState) : base(exception, cancelled, userState)
		{
			this.results = results;
		}
	}
}


text:
package org.apache.tinkerpop.gremlin.util;

import com.jcabi.manifests.Manifests;

import java.io.IOException;

/**
 * @author Stephen Mallette (http://stephen.genoprime.com)
 */
public final class Gremlin {
    private static final String version;

    static {
        version = Manifests.read("tinkerpop-version");
    }

    private Gremlin() {
    }

    public static String version() {
        return version;
    }

    public static void main(final String[] arguments) throws IOException {
        System.out.println("gremlin " + version());
    }
}


text:
<!DOCTYPE html>
<html>
  <head>
    <title>React Showcase</title>
    <meta charset="utf-8" />
    <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.2/html5shiv.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.2/html5shiv-printshiv.js"></script>
    <![endif]-->
    <link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css" />
    <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/codemirror/5.0.0/theme/monokai.min.css"/>
  </head>
  <body>
    <div id="root-component">
      <!-- this is where the root react component will get rendered -->
    </div>
    <!-- Normally, es5-shim is also in the conditional comment, but needed for phantomjs .bind() polyfill. -->
    <script src="//cdnjs.cloudflare.com/ajax/libs/es5-shim/4.1.1/es5-shim.min.js"></script>
    <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/es5-shim/4.1.1/es5-sham.min.js"></script>
    <![endif]-->
    <script src="//cdnjs.cloudflare.com/ajax/libs/codemirror/5.0.0/codemirror.min.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/codemirror/5.0.0/mode/javascript/javascript.min.js"></script>
    <script src="bundle.js"></script>
  </body>
</html>


text:
echo "Trashing Preferences..."
/usr/bin/defaults delete ~/Library/Preferences/org.latenitefilms.CommandPost.plist
rm ~/Library/Preferences/org.latenitefilms.CommandPost.plist

echo "Trashing Application Support..."
rm -R ~/Library/Application\ Support/CommandPost
rm -R ~/Library/Application Support/org.latenitefilms.CommandPost

echo "Trashing Caches..."
rm -R ~/Library/Preferences/Caches/org.latenitefilms.CommandPost
rm -R ~/Library/WebKit/org.latenitefilms.CommandPost


text:
The OpenLISP control plane (opencp) repository https://github.com/lip6-lisp/control-plane hosts an open source control plane for LISP (the Location/Idenfitier Separation Protocol), a protocol designed at the IETF.
It is designed to work on both linux and BSD platforms.

# For more info
http://www.lisp.ipv6.lip6.fr

# How to install ?

Require: expat library (need expat.h expat_external.h in /usr/local/include/)
	Installation of the expat library using ports collection (on FreeBSD) or packaging tool (on Linux).

	On FreeBSD:
		#cd /usr/ports/textproc/expat2
		#make clean install

	On Linux:(example for Ubuntu)
		#apt-get install libexpat1-dev

1. Make sure that you have the gcc compiler.
If you use other compiler, modify the Makefile to assign CC variable to your compiler.
(Note: default FreeBSD 10 use `clang` instead `gcc`)
	CC = gcc  --> CC = your_complier

2. From source code directory, run 'make'. This will create the binary file 'opencp'.

3. From source code directory, run 'make install' to install the service script to /etc/rc.d/.
It also copies the main configuration file (opencp.conf) and five other specific configuration files:
 'opencp_xtr.xml, opencp_ms.xml, opencp_mr.xml, opencp_node.xml, opencp_rtr.xml' to /etc/. Please edit
the configuration files to customize it before continuing. By default: opencp_mr-sample-configure-of-ddt-root.xml file
contains an example configuration for the DDT root node function; opencp_xtr-sample-configure-of-lisp-te.xml file contains an example  configuration of the RTR node function; opencp_xtr-sample-configure-multi-mapping-system.xml contains an example
configuration for the xTR node function.

	a.  The main configuration (opencp.conf) allows you to indicate what
control-plane function to enable. It also points to the specific xml configuration files for each functions.

	b.  The xTR configuration file (opencp_xtr.xml) includes:
	+ <mapserver> section: list of MSs the xTR registers to.
	Each MS needs an authentication key.
	+ <mapresolve> section: list of MRs the xTR can send map-requests to.
	+ One or more <eid> sections: each section gives the information of one EID IP prefix to register.

	c. Map server configuration file (opencp_ms.xml) includes:
	+ <geid> section: IP prefixes the map-server allows ETR to register to. The IP ranges must not overlap.
	+ One or more <site> sections: each section includes the information for one site:
		+ site name.
		+ key for map-register messages. NB: the key is case sensitive and must not include spaces.
		+ EID IP prefixes the site can register.

	d. DDT node and MR configuration file (opencp_mr.xml) includes:
	+ <geid> section: the IP prefix(es) the node is delegated. The IP ranges must not overlap.
	NB: if the node is a DDT root, then it is here configured as being delegated for 0.0.0.0/0 (IPv4) and 0::/0 (IPv6).
	+ One or more <eid> sections: each section contains the information for one delegated prefix.
	Special <eid> sections with prefix equal 0.0.0.0/0 or 0::/0 are for DDT root nodes.

	e. RTR configuration file (pencp_rtr.xml) includes:
	+ <mapresolve> section: list of MRs the RTR can send map-requests.
	+ One or more <eid> sections: each section includes the information for EID-prefix pass over RTR.

4. To start the program the first time, use 'service opencp start' or '/etc/rc.d/opencp_service start' command or run it manually by ./opencp -f [<path_to_opencp.conf>]

5. To let the program autostart when rebooting, edit the /etc/rc.conf adding the following line:
	opencp_enable="YES"

6. When running manually, opencp shows the log information to terminal. When run as a daemon (auto start when rebooting or by service command), opencp logs to `/var/log/opencp.log`. In FreeBSD, to rotate the log file, edit the /etc/newsyslog.conf and add the following line (opencp.log will be archived each time it gets over 1000KB):
	/var/log/opencp.log                     600  7     1000 *     JC    /var/run/opencp.pid  30

# Contact

Use github tracking system in case you encounter a bug.
Pull requests are welcome and should also go through the github system.

Reference
---------
DC. Phung, S. Secci, D. Saucez, L. Iannone, "The OpenLISP Control Plane Architecture", IEEE Network Magazine, 2014. Url: http://www-phare.lip6.fr/~secci/papers/PhSeSaIa-NETMAG14.pdf

Please acknowledge the paper above when using the code.


text:
<?php

namespace Zend\Soap\Exception;

class BadMethodCallException
    extends \BadMethodCallException
    implements \Zend\Soap\Exception
{
}


text:
package wl.gank.com.gankwl.view;

import android.support.v7.app.AppCompatActivity;

import rx.Subscription;
import rx.subscriptions.CompositeSubscription;

/**
 * Created by wanli on 2016/6/14.
 */
public class BaseActivity extends AppCompatActivity {
    private CompositeSubscription mCompositeSubscription;
    public void addSubscription(Subscription s) {
        if (this.mCompositeSubscription == null) {
            this.mCompositeSubscription = new CompositeSubscription();
        }
        this.mCompositeSubscription.add(s);
    }

}


text:
package mb.scopegraph.pepm16.terms;

import static mb.nabl2.terms.build.TermBuild.B;
import static mb.nabl2.terms.matching.TermMatch.M;

import java.util.List;

import org.immutables.serial.Serial;
import org.immutables.value.Value;

import com.google.common.collect.ImmutableList;

import mb.nabl2.terms.IApplTerm;
import mb.nabl2.terms.ITerm;
import mb.nabl2.terms.build.AbstractApplTerm;
import mb.nabl2.terms.matching.TermMatch.IMatcher;
import mb.scopegraph.pepm16.IScope;

@Value.Immutable
@Serial.Version(value = 42L)
public abstract class AScope extends AbstractApplTerm implements IScope, IApplTerm, Comparable<IScope> {

    private static final String OP = "Scope";

    // IScope implementation

    @Value.Parameter @Override public abstract String getResource();

    @Value.Parameter @Override public abstract String getName();

    // IApplTerm implementation

    @Override public String getOp() {
        return OP;
    }

    @Value.Lazy @Override public List<ITerm> getArgs() {
        return ImmutableList.of(B.newString(getResource()), B.newString(getName()));
    }

    public static IMatcher<Scope> matcher() {
        return M.preserveAttachments(
                M.appl2("Scope", M.stringValue(), M.stringValue(), (t, resource, name) -> Scope.of(resource, name)));
    }

    @Override protected AScope check() {
        return this;
    }

    // Object implementation

    @Override public boolean equals(Object other) {
        if(other == null) {
            return false;
        }
        if(other == this) {
            return true;
        }
        if(!(other instanceof Scope)) {
            return super.equals(other);
        }
        final Scope that = (Scope) other;
        if(!getResource().equals(that.getResource())) {
            return false;
        }
        if(!getName().equals(that.getName())) {
            return false;
        }
        return true;
    }

    @Override public int hashCode() {
        return super.hashCode();
    }

    @Override public String toString() {
        return "#" + getResource() + "-" + getName();
    }

    @Override public int compareTo(final IScope scope) {
        int diffResource = getResource().compareTo(scope.getResource());
        if(diffResource != 0) {
            return diffResource;
        }

        int diffName = getName().toString().compareTo(scope.getName());
        return diffName;
    }

}


text:
module NZMPsPopolo
  module Serializers
    class PersonSerializer < BaseSerializer
      def to_popolo
        {
          id: record.entry_id,
          name: record.name
        }
      end
    end
  end
end


text:
require 'spec_helper'

require 'protobuf/code_generator'
require 'protobuf/generators/base'

RSpec.describe ::Protobuf::Generators::Base do

  subject(:generator) { described_class.new(double) }

  context 'namespaces' do
    let(:descriptor) { double(:name => 'Baz') }
    subject { described_class.new(descriptor, 0, :namespace => [:foo, :bar]) }
    specify { expect(subject.type_namespace).to eq([:foo, :bar, 'Baz']) }
    specify { expect(subject.fully_qualified_type_namespace).to eq('.foo.bar.Baz') }
  end

  describe '#run_once' do
    it 'protects the block from being entered more than once' do
      foo = 0
      bar = 0

      test_run_once = lambda do
        bar += 1
        subject.run_once(:foo_test) do
          foo += 1
        end
      end

      10.times { test_run_once.call }
      expect(foo).to eq(1)
      expect(bar).to eq(10)
    end

    it 'always returns the same object' do
      rv = subject.run_once(:foo_test) do
        "foo bar"
      end
      expect(rv).to eq("foo bar")

      rv = subject.run_once(:foo_test) do
        "baz quux"
      end
      expect(rv).to eq("foo bar")
    end
  end

  describe '#to_s' do
    before do
      class ToStringTest < ::Protobuf::Generators::Base
        def compile
          run_once(:compile) do
            puts "this is a test"
          end
        end
      end
    end

    subject { ToStringTest.new(double) }

    it 'compiles and returns the contents' do
      10.times do
        expect(subject.to_s).to eq("this is a test\n")
      end
    end
  end

  describe '#validate_tags' do
    context 'when tags are duplicated' do
      it 'fails with a GeneratorFatalError' do
        expect(::Protobuf::CodeGenerator).to receive(:fatal).with(/FooBar object has duplicate tags\. Expected 3 tags, but got 4/)
        described_class.validate_tags("FooBar", [1, 2, 2, 3])
      end
    end

    context 'when tags are missing in the range' do
      it 'prints a warning' do
        allow(ENV).to receive(:key?).and_call_original
        allow(ENV).to receive(:key?).with("PB_NO_TAG_WARNINGS").and_return(false)
        expect(::Protobuf::CodeGenerator).to receive(:print_tag_warning_suppress)
        expect(::Protobuf::CodeGenerator).to receive(:warn).with(/FooBar object should have 5 tags \(1\.\.5\), but found 4 tags/)
        described_class.validate_tags("FooBar", [1, 2, 4, 5])
      end
    end
  end

  describe '#serialize_value' do
    before do
      stub_const("MyEnum", Class.new(::Protobuf::Enum) do
        define :FOO, 1
        define :BOO, 2
      end)
      stub_const("MyMessage1", Class.new(Protobuf::Message) do
        optional :string, :foo, 1
      end)
      stub_const("MyMessage2", Class.new(Protobuf::Message) do
        optional :string, :foo, 1
        optional MyMessage1, :bar, 2
        optional :int32, :boom, 3
        optional MyEnum, :goat, 4
        optional :bool, :bam, 5
        optional :float, :fire, 6
      end)
      stub_const("MyMessage3", Class.new(Protobuf::Message) do
        optional :string, :foo, 1
        repeated MyMessage2, :bar, 2
        optional :int32, :boom, 3
        optional MyEnum, :goat, 4
        optional :bool, :bam, 5
        optional :float, :fire, 6
      end)
    end

    it 'serializes messages' do
      output_string = <<-STRING
        { :foo => "space",
          :bar => [{
            :foo => "station",
            :bar => { :foo => "orbit" },
            :boom => 123,
            :goat => ::MyEnum::FOO,
            :bam => false,
            :fire => 3.5 }],
          :boom => 456,
          :goat => ::MyEnum::BOO,
          :bam => true, :fire => 1.2 }
      STRING

      output_string.lstrip!
      output_string.rstrip!
      output_string.delete!("\n")
      output_string.squeeze!(" ")
      expect(generator.serialize_value(MyMessage3.new(
                                         :foo => 'space',
                                         :bar => [MyMessage2.new(
                                           :foo => 'station',
                                           :bar => MyMessage1.new(:foo => 'orbit'),
                                           :boom => 123,
                                           :goat => MyEnum::FOO,
                                           :bam => false,
                                           :fire => 3.5
                                         )],
                                         :boom => 456,
                                         :goat => MyEnum::BOO,
                                         :bam => true,
                                         :fire => 1.2
      ))).to eq(output_string)
    end

    it 'serializes enums' do
      expect(generator.serialize_value(MyEnum::FOO)).to eq("::MyEnum::FOO")
      expect(generator.serialize_value(MyEnum::BOO)).to eq("::MyEnum::BOO")
    end
  end
end


text:
static NSString *const kCellIdentifier = @"Cell";
static NSString *const kSectionHeaderIdentifier = @"SectionHeader";

@implementation TitlesDataSource

- (void)registerReusableViewsForTableView:(UITableView *)tableView {
    [super registerReusableViewsForTableView:tableView];
    [tableView registerClass:[UITableViewCell class] forCellReuseIdentifier:kCellIdentifier];
}

- (void)registerReusableViewsForCollectionView:(UICollectionView *)collectionView {
    [super registerReusableViewsForCollectionView:collectionView];
    [collectionView registerClass:[CollectionViewCell class] forCellWithReuseIdentifier:kCellIdentifier];
    [collectionView registerClass:[CollectionSectionHeaderView class] forSupplementaryViewOfKind:UICollectionElementKindSectionHeader withReuseIdentifier:kSectionHeaderIdentifier];
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:kCellIdentifier forIndexPath:indexPath];
    cell.textLabel.text = [self stringValueForItemAtIndexPath:indexPath];
    return cell;
}

- (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath
{
    CollectionViewCell *cell = [collectionView dequeueReusableCellWithReuseIdentifier:kCellIdentifier forIndexPath:indexPath];
    cell.textLabel.text = [self stringValueForItemAtIndexPath:indexPath];
    cell.contentView.backgroundColor = [UIColor colorWithWhite:0.95f alpha:1.0f];
    return cell;
}

- (UICollectionReusableView *)collectionView:(UICollectionView *)collectionView viewForSupplementaryElementOfKind:(NSString *)kind atIndexPath:(NSIndexPath *)indexPath
{
    CollectionSectionHeaderView *const headerView = [collectionView dequeueReusableSupplementaryViewOfKind:UICollectionElementKindSectionHeader withReuseIdentifier:kSectionHeaderIdentifier forIndexPath:indexPath];
    MUKDataSourceContentSection * const section = [self sectionAtIndex:indexPath.section];
    headerView.textLabel.text = [section.header isKindOfClass:[NSString class]] ? (NSString *)section.header : nil;
    return headerView;
}

- (NSString *)stringValueForItemAtIndexPath:(NSIndexPath *)indexPath {
    NSString *value;
    id<MUKDataSourceIdentifiable> const item = [self itemAtIndexPath:indexPath];

    if ([item isKindOfClass:[NSString class]]) {
        value = (NSString *)item;
    }
    else if ([item respondsToSelector:@selector(title)]) {
        value = [(id)item title];
    }
    else {
        value = nil;
    }

    return value;
}

@end


text:
{{+bindTo:partials.standard_nacl_api}}

module.h File Reference

{{- dummy div to appease doxygen -}}

Include dependency graph for module.h:

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

Classes

class  	pp::Module

 	The Module class.  More...

Namespaces

namespace  	pp

Detailed Description

This file defines a Module class.

{{/partials.standard_nacl_api}}


text:
- [wikipedia](https://www.wikipedia.org)
- [GitHub](https://github.com)


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace ConnectedServiceSample.Views
{
    /// <summary>
    /// Interaction logic for SinglePageView.xaml
    /// </summary>
    public partial class SinglePageView : UserControl
    {
        public SinglePageView()
        {
            InitializeComponent();
        }
    }
}


text:
@interface TopBar : UIView

@property id<AddMemoDelegate>delegate;

-(void)hideButton;

-(void)showButton;

@end


text:
<?xml version="1.0" encoding="UTF-8"?>
<package xmlns="http://expath.org/ns/pkg" name="http://rest3d.org/rest3d" abbrev="rest3d" version="0.1" spec="1.0">
    <title>rest3d service</title>
    <dependency package="http://exist-db.org/apps/shared"/>
</package>


text: {{catagory}}


text:
from time import sleep
from org.myrobotlab.service import Arduino

# create an Arduino service named arduino
arduino = runtime.createAndStart("arduino","Arduino")

# set the board type
arduino.setBoard("atmega168") # atmega168 | mega2560 | etc

# set serial device
arduino.connect("/dev/ttyUSB0",57600,8,1,0)
sleep(1) # give it a second for the serial device to get ready

# update the gui with configuration changes
arduino.publishState()

# set the pinMode of pin 13 to output
arduino.pinMode(13, Arduino.OUTPUT)

# turn pin 13 on and off 10 times
for x in range(0, 10):
	arduino.digitalWrite(13, Arduino.HIGH)
	sleep(0.5) # sleep half a second
	arduino.digitalWrite(13, Arduino.LOW)
	sleep(0.5) # sleep half a second

# set the pinMode of pwm pin 9 to output
arduino.pinMode(9, Arduino.OUTPUT)

# run through pin 9's pwm frequency 5 times
# in increments of 10 - dim to bright
for y in range(0, 5):
  for x in range(0, 255, 10):
	  arduino.analogWrite(9, x)
	  sleep(0.1) # sleep a 1 tenth of a second

# turn out the lights :)
arduino.analogWrite(9, 0)


text:
<?php

namespace yii\db\mssql;

use yii\base\InvalidParamException;

/**
 * QueryBuilder is the query builder for MS SQL Server databases (version 2008 and above).
 *
 * @author Timur Ruziev <resurtm@gmail.com>
 * @since 2.0
 */
class QueryBuilder extends \yii\db\QueryBuilder
{
    /**
     * @var array mapping from abstract column types (keys) to physical column types (values).
     */
    public $typeMap = [
        Schema::TYPE_PK => 'int IDENTITY PRIMARY KEY',
        Schema::TYPE_BIGPK => 'bigint IDENTITY PRIMARY KEY',
        Schema::TYPE_STRING => 'varchar(255)',
        Schema::TYPE_TEXT => 'text',
        Schema::TYPE_SMALLINT => 'smallint',
        Schema::TYPE_INTEGER => 'int',
        Schema::TYPE_BIGINT => 'bigint',
        Schema::TYPE_FLOAT => 'float',
        Schema::TYPE_DECIMAL => 'decimal',
        Schema::TYPE_DATETIME => 'datetime',
        Schema::TYPE_TIMESTAMP => 'timestamp',
        Schema::TYPE_TIME => 'time',
        Schema::TYPE_DATE => 'date',
        Schema::TYPE_BINARY => 'binary',
        Schema::TYPE_BOOLEAN => 'bit',
        Schema::TYPE_MONEY => 'decimal(19,4)',
    ];

//	public function update($table, $columns, $condition, &$params)
//	{
//		return '';
//	}

//	public function delete($table, $condition, &$params)
//	{
//		return '';
//	}

    /**
     * @param integer $limit
     * @param integer $offset
     * @return string the LIMIT and OFFSET clauses built from [[\yii\db\Query::$limit]].
     */
    public function buildLimit($limit, $offset = 0)
    {
        $hasOffset = $this->hasOffset($offset);
        $hasLimit = $this->hasLimit($limit);
        if ($hasOffset || $hasLimit) {
            // http://technet.microsoft.com/en-us/library/gg699618.aspx
            $sql = 'OFFSET ' . ($hasOffset ? $offset : '0') . ' ROWS';
            if ($hasLimit) {
                $sql .= " FETCH NEXT $limit ROWS ONLY";
            }

            return $sql;
        } else {
            return '';
        }
    }

//	public function resetSequence($table, $value = null)
//	{
//		return '';
//	}

    /**
     * Builds a SQL statement for renaming a DB table.
     * @param string $table the table to be renamed. The name will be properly quoted by the method.
     * @param string $newName the new table name. The name will be properly quoted by the method.
     * @return string the SQL statement for renaming a DB table.
     */
    public function renameTable($table, $newName)
    {
        return "sp_rename '$table', '$newName'";
    }

    /**
     * Builds a SQL statement for renaming a column.
     * @param string $table the table whose column is to be renamed. The name will be properly quoted by the method.
     * @param string $name the old name of the column. The name will be properly quoted by the method.
     * @param string $newName the new name of the column. The name will be properly quoted by the method.
     * @return string the SQL statement for renaming a DB column.
     */
    public function renameColumn($table, $name, $newName)
    {
        return "sp_rename '$table.$name', '$newName', 'COLUMN'";
    }

    /**
     * Builds a SQL statement for changing the definition of a column.
     * @param string $table the table whose column is to be changed. The table name will be properly quoted by the method.
     * @param string $column the name of the column to be changed. The name will be properly quoted by the method.
     * @param string $type the new column type. The [[getColumnType]] method will be invoked to convert abstract column type (if any)
     * into the physical one. Anything that is not recognized as abstract type will be kept in the generated SQL.
     * For example, 'string' will be turned into 'varchar(255)', while 'string not null' will become 'varchar(255) not null'.
     * @return string the SQL statement for changing the definition of a column.
     */
    public function alterColumn($table, $column, $type)
    {
        $type = $this->getColumnType($type);
        $sql = 'ALTER TABLE ' . $this->db->quoteTableName($table) . ' ALTER COLUMN '
            . $this->db->quoteColumnName($column) . ' '
            . $this->getColumnType($type);

        return $sql;
    }

    /**
     * Builds a SQL statement for enabling or disabling integrity check.
     * @param boolean $check whether to turn on or off the integrity check.
     * @param string $schema the schema of the tables. Defaults to empty string, meaning the current or default schema.
     * @param string $table the table name. Defaults to empty string, meaning that no table will be changed.
     * @return string the SQL statement for checking integrity
     * @throws InvalidParamException if the table does not exist or there is no sequence associated with the table.
     */
    public function checkIntegrity($check = true, $schema = '', $table = '')
    {
        if ($schema !== '') {
            $table = "{$schema}.{$table}";
        }
        $table = $this->db->quoteTableName($table);
        if ($this->db->getTableSchema($table) === null) {
            throw new InvalidParamException("Table not found: $table");
        }
        $enable = $check ? 'CHECK' : 'NOCHECK';

        return "ALTER TABLE {$table} {$enable} CONSTRAINT ALL";
    }

    /**
     * @inheritdoc
     */
    public function buildOrderBy($columns)
    {
        if (empty($columns)) {
            // hack so LIMIT will work if no ORDER BY is specified
            return 'ORDER BY (SELECT NULL)';
        } else {
            return parent::buildOrderBy($columns);
        }
    }

    /**
     * @inheritdoc
     */
    public function build($query, $params = [])
    {
        $query->prepareBuild($this);

        $params = empty($params) ? $query->params : array_merge($params, $query->params);

        $clauses = [
            $this->buildSelect($query->select, $params, $query->distinct, $query->selectOption),
            $this->buildFrom($query->from, $params),
            $this->buildJoin($query->join, $params),
            $this->buildWhere($query->where, $params),
            $this->buildGroupBy($query->groupBy),
            $this->buildHaving($query->having, $params),
            $this->buildOrderBy($query->orderBy),
            $this->isOldMssql() ? '' : $this->buildLimit($query->limit, $query->offset),
        ];

        $sql = implode($this->separator, array_filter($clauses));
        if ($this->isOldMssql()) {
            $sql = $this->applyLimitAndOffset($sql, $query);
        }
        $union = $this->buildUnion($query->union, $params);
        if ($union !== '') {
            $sql = "($sql){$this->separator}$union";
        }

        return [$sql, $params];
    }

    /**
     * Applies limit and offset to SQL query
     *
     * @param string $sql SQL query
     * @param \yii\db\ActiveQuery $query the [[Query]] object from which the SQL statement generated
     * @return string resulting SQL
     */
    private function applyLimitAndOffset($sql, $query)
    {
        $limit = $query->limit !== null ? (int)$query->limit : -1;
        $offset = $query->offset !== null ? (int)$query->offset : -1;
        if ($limit > 0 || $offset >= 0) {
            $sql = $this->rewriteLimitOffsetSql($sql, $limit, $offset, $query);
        }
        return $sql;
    }

    /**
     * Rewrites limit and offset in SQL query
     *
     * @param string $sql SQL query
     * @param integer $limit
     * @param integer $offset
     * @param \yii\db\ActiveQuery $query the [[Query]] object from which the SQL statement generated
     * @return string resulting SQL query
     */
    private function rewriteLimitOffsetSql($sql, $limit, $offset, $query)
    {
        $originalOrdering = $this->buildOrderBy($query->orderBy);
        if ($query->select) {
            $select = implode(', ', $query->select);
        }
        else {
            $select = $query->select = '*';
        }
        if ($select === '*') {
            $columns = $this->getAllColumnNames($query->modelClass);
            if ($columns && is_array($columns)) {
                $select = implode(', ', $columns);
            } else {
                $select = $columns;
            }
        }
        $sql = str_replace($originalOrdering, '', $sql);
        $sql = preg_replace('/^([\s(])*SELECT( DISTINCT)?(?!\s*TOP\s*\()/i', "\\1SELECT\\2 rowNum = ROW_NUMBER() over ({$originalOrdering}),", $sql);
        $sql = "SELECT TOP {$limit} {$select} FROM ($sql) sub WHERE rowNum > {$offset}";
        return $sql;
    }

    /**
     * Returns an array of column names given model name
     *
     * @param string $modelClass name of the model class
     * @return array|null array of column names
     */
    protected function getAllColumnNames($modelClass = null)
    {
        if (!$modelClass) {
            return null;
        }
        /** @var \yii\db\ActiveRecord $model */
        $model = new $modelClass;
        $schema = $model->getTableSchema();
        $columns = array_keys($schema->columns);
        return $columns;
    }

    /**
     * @return boolean if MSSQL used is old
     * @throws \yii\base\InvalidConfigException
     * @throws \yii\db\Exception
     */
    protected function isOldMssql()
    {
        $this->db->open();
        $version = preg_split("/\./", $this->db->pdo->getAttribute(\PDO::ATTR_SERVER_VERSION));
        return $version[0] < 11;
    }
}


text:
package com.sunzn.utils.library;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.Uri;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

/**
 * Helper to register for and send broadcasts of Intents to local objects
 * within your process.  This is has a number of advantages over sending
 * global broadcasts with {@link android.content.Context#sendBroadcast}:
 *

 *
 You know that the data you are broadcasting won't leave your app, so
 * don't need to worry about leaking private data.
 *
 It is not possible for other applications to send these broadcasts to
 * your app, so you don't need to worry about having security holes they can
 * exploit.
 *
 It is more efficient than sending a global broadcast through the
 * system.
 *

 */
public class LocalBroadcastManager {
    private static class ReceiverRecord {
        final IntentFilter filter;
        final BroadcastReceiver receiver;
        boolean broadcasting;

        ReceiverRecord(IntentFilter _filter, BroadcastReceiver _receiver) {
            filter = _filter;
            receiver = _receiver;
        }

        @Override
        public String toString() {
            StringBuilder builder = new StringBuilder(128);
            builder.append("Receiver{");
            builder.append(receiver);
            builder.append(" filter=");
            builder.append(filter);
            builder.append("}");
            return builder.toString();
        }
    }

    private static class BroadcastRecord {
        final Intent intent;
        final ArrayList<ReceiverRecord> receivers;

        BroadcastRecord(Intent _intent, ArrayList<ReceiverRecord> _receivers) {
            intent = _intent;
            receivers = _receivers;
        }
    }

    private static final String TAG = "LocalBroadcastManager";
    private static final boolean DEBUG = false;

    private final Context mAppContext;

    private final HashMap<BroadcastReceiver, ArrayList<IntentFilter>> mReceivers
            = new HashMap<BroadcastReceiver, ArrayList<IntentFilter>>();
    private final HashMap<String, ArrayList<ReceiverRecord>> mActions
            = new HashMap<String, ArrayList<ReceiverRecord>>();

    private final ArrayList<BroadcastRecord> mPendingBroadcasts
            = new ArrayList<BroadcastRecord>();

    static final int MSG_EXEC_PENDING_BROADCASTS = 1;

    private final Handler mHandler;

    private static final Object mLock = new Object();
    private static LocalBroadcastManager mInstance;

    public static LocalBroadcastManager getInstance(Context context) {
        synchronized (mLock) {
            if (mInstance == null) {
                mInstance = new LocalBroadcastManager(context.getApplicationContext());
            }
            return mInstance;
        }
    }

    private LocalBroadcastManager(Context context) {
        mAppContext = context;
        mHandler = new Handler(context.getMainLooper()) {

            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MSG_EXEC_PENDING_BROADCASTS:
                        executePendingBroadcasts();
                        break;
                    default:
                        super.handleMessage(msg);
                }
            }
        };
    }

    /**
     * Register a receive for any local broadcasts that match the given IntentFilter.
     *
     * @param receiver The BroadcastReceiver to handle the broadcast.
     * @param filter Selects the Intent broadcasts to be received.
     *
     * @see #unregisterReceiver
     */
    public void registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
        synchronized (mReceivers) {
            ReceiverRecord entry = new ReceiverRecord(filter, receiver);
            ArrayList<IntentFilter> filters = mReceivers.get(receiver);
            if (filters == null) {
                filters = new ArrayList<IntentFilter>(1);
                mReceivers.put(receiver, filters);
            }
            filters.add(filter);
            for (int i=0; i<filter.countActions(); i++) {
                String action = filter.getAction(i);
                ArrayList<ReceiverRecord> entries = mActions.get(action);
                if (entries == null) {
                    entries = new ArrayList<ReceiverRecord>(1);
                    mActions.put(action, entries);
                }
                entries.add(entry);
            }
        }
    }

    /**
     * Unregister a previously registered BroadcastReceiver.  All
     * filters that have been registered for this BroadcastReceiver will be
     * removed.
     *
     * @param receiver The BroadcastReceiver to unregister.
     *
     * @see #registerReceiver
     */
    public void unregisterReceiver(BroadcastReceiver receiver) {
        synchronized (mReceivers) {
            ArrayList<IntentFilter> filters = mReceivers.remove(receiver);
            if (filters == null) {
                return;
            }
            for (int i=0; i<filters.size(); i++) {
                IntentFilter filter = filters.get(i);
                for (int j=0; j<filter.countActions(); j++) {
                    String action = filter.getAction(j);
                    ArrayList<ReceiverRecord> receivers = mActions.get(action);
                    if (receivers != null) {
                        for (int k=0; k<receivers.size(); k++) {
                            if (receivers.get(k).receiver == receiver) {
                                receivers.remove(k);
                                k--;
                            }
                        }
                        if (receivers.size() <= 0) {
                            mActions.remove(action);
                        }
                    }
                }
            }
        }
    }

    /**
     * Broadcast the given intent to all interested BroadcastReceivers.  This
     * call is asynchronous; it returns immediately, and you will continue
     * executing while the receivers are run.
     *
     * @param intent The Intent to broadcast; all receivers matching this
     *     Intent will receive the broadcast.
     *
     * @see #registerReceiver
     */
    public boolean sendBroadcast(Intent intent) {
        synchronized (mReceivers) {
            final String action = intent.getAction();
            final String type = intent.resolveTypeIfNeeded(
                    mAppContext.getContentResolver());
            final Uri data = intent.getData();
            final String scheme = intent.getScheme();
            final Set<String> categories = intent.getCategories();

            final boolean debug = DEBUG ||
                    ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0);
            if (debug) Log.v(
                    TAG, "Resolving type " + type + " scheme " + scheme
                    + " of intent " + intent);

            ArrayList<ReceiverRecord> entries = mActions.get(intent.getAction());
            if (entries != null) {
                if (debug) Log.v(TAG, "Action list: " + entries);

                ArrayList<ReceiverRecord> receivers = null;
                for (int i=0; i<entries.size(); i++) {
                    ReceiverRecord receiver = entries.get(i);
                    if (debug) Log.v(TAG, "Matching against filter " + receiver.filter);

                    if (receiver.broadcasting) {
                        if (debug) {
                            Log.v(TAG, "  Filter's target already added");
                        }
                        continue;
                    }

                    int match = receiver.filter.match(action, type, scheme, data,
                            categories, "LocalBroadcastManager");
                    if (match >= 0) {
                        if (debug) Log.v(TAG, "  Filter matched!  match=0x" +
                                Integer.toHexString(match));
                        if (receivers == null) {
                            receivers = new ArrayList<ReceiverRecord>();
                        }
                        receivers.add(receiver);
                        receiver.broadcasting = true;
                    } else {
                        if (debug) {
                            String reason;
                            switch (match) {
                                case IntentFilter.NO_MATCH_ACTION: reason = "action"; break;
                                case IntentFilter.NO_MATCH_CATEGORY: reason = "category"; break;
                                case IntentFilter.NO_MATCH_DATA: reason = "data"; break;
                                case IntentFilter.NO_MATCH_TYPE: reason = "type"; break;
                                default: reason = "unknown reason"; break;
                            }
                            Log.v(TAG, "  Filter did not match: " + reason);
                        }
                    }
                }

                if (receivers != null) {
                    for (int i=0; i<receivers.size(); i++) {
                        receivers.get(i).broadcasting = false;
                    }
                    mPendingBroadcasts.add(new BroadcastRecord(intent, receivers));
                    if (!mHandler.hasMessages(MSG_EXEC_PENDING_BROADCASTS)) {
                        mHandler.sendEmptyMessage(MSG_EXEC_PENDING_BROADCASTS);
                    }
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Like {@link #sendBroadcast(Intent)}, but if there are any receivers for
     * the Intent this function will block and immediately dispatch them before
     * returning.
     */
    public void sendBroadcastSync(Intent intent) {
        if (sendBroadcast(intent)) {
            executePendingBroadcasts();
        }
    }

    private void executePendingBroadcasts() {
        while (true) {
            BroadcastRecord[] brs = null;
            synchronized (mReceivers) {
                final int N = mPendingBroadcasts.size();
                if (N <= 0) {
                    return;
                }
                brs = new BroadcastRecord[N];
                mPendingBroadcasts.toArray(brs);
                mPendingBroadcasts.clear();
            }
            for (int i=0; i<brs.length; i++) {
                BroadcastRecord br = brs[i];
                for (int j=0; j<br.receivers.size(); j++) {
                    br.receivers.get(j).receiver.onReceive(mAppContext, br.intent);
                }
            }
        }
    }
}


text:
package com.google.android.exoplayer2;

import androidx.annotation.IntDef;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/** A timeout of an operation on the ExoPlayer playback thread. */
public final class ExoTimeoutException extends RuntimeException {

  /**
   * The operation which produced the timeout error. One of {@link #TIMEOUT_OPERATION_RELEASE},
   * {@link #TIMEOUT_OPERATION_SET_FOREGROUND_MODE}, {@link #TIMEOUT_OPERATION_DETACH_SURFACE} or
   * {@link #TIMEOUT_OPERATION_UNDEFINED}. Note that new operations may be added in the future and
   * error handling should handle unknown operation values.
   */
  @Documented
  @Retention(RetentionPolicy.SOURCE)
  @IntDef({
    TIMEOUT_OPERATION_UNDEFINED,
    TIMEOUT_OPERATION_RELEASE,
    TIMEOUT_OPERATION_SET_FOREGROUND_MODE,
    TIMEOUT_OPERATION_DETACH_SURFACE
  })
  public @interface TimeoutOperation {}

  /** The operation where this error occurred is not defined. */
  public static final int TIMEOUT_OPERATION_UNDEFINED = 0;
  /** The error occurred in {@link Player#release}. */
  public static final int TIMEOUT_OPERATION_RELEASE = 1;
  /** The error occurred in {@link ExoPlayer#setForegroundMode}. */
  public static final int TIMEOUT_OPERATION_SET_FOREGROUND_MODE = 2;
  /** The error occurred while detaching a surface from the player. */
  public static final int TIMEOUT_OPERATION_DETACH_SURFACE = 3;

  /** The operation on the ExoPlayer playback thread that timed out. */
  @TimeoutOperation public final int timeoutOperation;

  /**
   * Creates the timeout exception.
   *
   * @param timeoutOperation The {@link TimeoutOperation operation} that produced the timeout.
   */
  public ExoTimeoutException(@TimeoutOperation int timeoutOperation) {
    super(getErrorMessage(timeoutOperation));
    this.timeoutOperation = timeoutOperation;
  }

  private static String getErrorMessage(@TimeoutOperation int timeoutOperation) {
    switch (timeoutOperation) {
      case TIMEOUT_OPERATION_RELEASE:
        return "Player release timed out.";
      case TIMEOUT_OPERATION_SET_FOREGROUND_MODE:
        return "Setting foreground mode timed out.";
      case TIMEOUT_OPERATION_DETACH_SURFACE:
        return "Detaching surface timed out.";
      case TIMEOUT_OPERATION_UNDEFINED:
      default:
        return "Undefined timeout.";
    }
  }
}


text:
package be.peopleware.theopenmoviedb;

import be.peopleware.theopenmoviedb.MovieService;
import be.peopleware.theopenmoviedb.model.Movie;

public class UtilTest {

	public static void main(String[] args) {
		String query = "the matrix";
		for (Movie movie : MovieService.searchForMovies(query)) {
			System.out.println(movie.getName() + " (" + movie.getImdbId() + ") : " + movie.getOverview());
		}

		String queryId = "24";
		Movie movie = MovieService.searchForMovie(queryId);
		System.out.println(movie.getName() + " (" + movie.getImdbId() + ") : " + movie.getOverview());
		System.out.println(movie.getActors());
		for(String s : TMDBProxy.getMainActors(queryId)) {
			System.out.println(s);
		}
	}

}


text:
package io.github.mmhelloworld.idrisjvm.runtime;

public final class ErrorCodes {
    public static final int SUCCESS = 0;
    public static final int NO_SUCH_FILE = 2;
    public static final int IO_ERROR = 5;
    public static final int SOCKET_ACCESS_DENIED = 13;
    public static final int INTERRUPTED = 4;
    public static final int UNSUPPORTED_SOCKET_TYPE = 44;
    public static final int CANNOT_ASSIGN_REQUESTED_ADDRESS = 49;
    public static final int NO_ROUTE_TO_HOST = 65;
    public static final int PROTOCOL_ERROR = 86;

    private ErrorCodes() {
    }
}


text:
if [[ $OSTYPE == darwin* ]]; then
     export LDFLAGS="${LDFLAGS} -headerpad_max_install_names"
fi

$PYTHON setup.py install

# Add more build steps here, if they are necessary.

# See
# http://docs.continuum.io/conda/build.html
# for a list of environment variables that are set during the build process.


text:
var assert = require('chai').assert;
var expect = require('chai').expect;

describe('CommandBuilderWorks', function(){
  var commandBuilder = require('../../test-tmp/CommandBuilder');
  it('Should not throw when files are passed in', function(){
    var testObject = {
      heatFiles: ['tst'],
      candleFiles: ['awesome'],
      lightFiles: ['filesss']
    };
    commandBuilder(testObject)

  });
  it('Should not throw when commands are passed in', function(){
    var testObject = {
      heatCommands: ['tst'],
      candleCommands: ['awesome'],
      lightCommands: ['filesss']
    };
    commandBuilder(testObject)

  });

  it('Should Throw if missing light files', function(){
    var testObject = {
      heatFiles: ['tst'],
      candleFiles: ['awesome']
    };
    assert.throws(()=>commandBuilder(testObject));

  });
  it('Should Throw if missing candle files', function(){
    var testObject = {
      heatFiles: ['tst'],
      lightFiles: ['awesome']
    };
    assert.throws(()=>commandBuilder(testObject));

  });
  it('Should not Throw if missing heat files or commands', function(){
    var testObject = {
      lightFiles: ['awesome'],
      candleFiles: ['awesome']
    };
    assert.doesNotThrow(()=>commandBuilder(testObject));

  });

  it('should run as expected with files', function(){
    var testObject = {
      lightFiles: ['lightfile'],
      candleFiles: ['candlefile'],
      heatFiles: ['heatfile']
    };
    var result = commandBuilder(testObject);
    expect(result.heatCommands).to.eql(['@heatfile']);
    expect(result.lightCommands).to.eql(['@lightfile']);
    expect(result.candleCommands).to.eql(['@candlefile']);
  });

  it('should run as expected with commands', function(){
    var testObject = {
      lightCommands: ['lightfile'],
      candleCommands: ['candlefile'],
      heatCommands: ['heatfile']
    };
    var result = commandBuilder(testObject);
    expect(result.heatCommands).to.eql(['heatfile']);
    expect(result.lightCommands).to.eql(['lightfile']);
    expect(result.candleCommands).to.eql(['candlefile']);
  });

  it('should use alternate heat location', function(){
    var testObject = {
      lightCommands: ['lightfile'],
      candleCommands: ['candlefile'],
      heatCommands: ['heatfile'],
      heatPath: "../awesome"
    };
    var result = commandBuilder(testObject);
    expect(result.heatPath).to.eql("../awesome");
  });

  it('should use alternate candle location', function(){
    var testObject = {
      lightCommands: ['lightfile'],
      candleCommands: ['candlefile'],
      heatCommands: ['heatfile'],
      candlePath: "../awesome"
    };
    var result = commandBuilder(testObject);
    expect(result.candlePath).to.eql("../awesome");
  });

  it('should use alternate light location', function(){
    var testObject = {
      lightCommands: ['lightfile'],
      candleCommands: ['candlefile'],
      heatCommands: ['heatfile'],
      lightPath: "../awesome"
    };
    var result = commandBuilder(testObject);
    expect(result.lightPath).to.eql("../awesome");
  });
  it('should suppress validations', function(){
    var testObject = {
      lightCommands: ['lightfile'],
      candleCommands: ['candlefile'],
      heatCommands: ['heatfile'],
      suppressValidation: true
    };
  var result = commandBuilder(testObject);
  expect(result.lightCommands).to.eql(['-sval', 'lightfile']);
  });

});


text:
namespace RemoveOddOccuranceOfNumberTests
{
    using System;
    using System.Collections.Generic;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using RemoveOddOccuranceOfNumber;

    [TestClass]
    public class RemoveOddOccuranceOfNumberTests
    {
        [TestMethod]
        public void RemoveOddElementsTest1()
        {
            LinkedList<int> sequence = new LinkedList<int>(new int[] { 1, 3, 5, 3, 3, 5, 5, 6, 2, 5, 6, 3 });
            RemoveOddOccuranceOfNumber.RemoveOddElements(sequence);
            var actual = sequence;
            LinkedList<int> expected = new LinkedList<int>(new int[] { 3, 5, 3, 3, 5, 5, 6, 5, 6, 3 });
            CollectionAssert.AreEqual(expected, actual);
        }

        [TestMethod]
        public void RemoveOddElementsTest2()
        {
            LinkedList<int> sequence = new LinkedList<int>(new int[] { 1, 1, 1, 1, 1 });
            RemoveOddOccuranceOfNumber.RemoveOddElements(sequence);
            var actual = sequence;
            LinkedList<int> expected = new LinkedList<int>();
            CollectionAssert.AreEqual(expected, actual);
        }

        [TestMethod]
        public void RemoveOddElementsTest3()
        {
            LinkedList<int> sequence = new LinkedList<int>(new int[] { 1, 1, 2, 2 });
            RemoveOddOccuranceOfNumber.RemoveOddElements(sequence);
            var actual = sequence;
            LinkedList<int> expected = new LinkedList<int>(new int[] { 1, 1, 2, 2 });
            CollectionAssert.AreEqual(expected, actual);
        }
    }
}


text:
var httpServer = require('http-server'),
    childProcess = require('child_process'),
    colors = require('colors');

var port = 8080,
    xDomainPort = 8081,
    host = '127.0.0.1',
    phantomJsIndex = __dirname + "/phantomjs-index.js";

var PHANTOM_BINARY = __dirname + '/../../node_modules/.bin/phantomjs';

function startHttpServer(port, host, callback) {
    var options = {
        root: __dirname,
        autoIndex: true,
        cache: true
    };

    function onListening() {
        console.log('info'.green + ':    Starting up http-server, serving ' + server.root.green + ' on port: ' + port);
        callback();
    }

    var server = httpServer.createServer(options);
    server.listen(port, host, onListening);

    if (process.platform !== 'win32') {
        //
        // Signal handlers don't work on Windows.
        //
        process.on('SIGINT', function () {
            console.warn('Http-server stopped');
            process.exit(1);
        });
    }

    return server;
}

function runTestInPhantomJsEnvironment(runner, url, callback) {
    console.log('info'.green + ':    Starting up phantomjs, with runner ' + runner.green + ' and url ' + url.green);

    var ps = childProcess.spawn(PHANTOM_BINARY, [runner, url]);

    process.stdout.write('test'.cyan + ':    ');
    ps.stdout.on('data', function(buffer) {
        // Proxy & colorize data
        var lines = buffer.toString('utf8')
            .split('\n')
            .map(function (line) {
                if (line.charAt(0) === "#") {
                    return line.blue;
                }
                return line;
            })
            .join('\n' + 'test'.cyan + ':    ');

        return process.stdout.write(lines);
    });

    ps.stderr.on('data', function(buffer) {
        return console.warn(buffer.toString('utf8').red);
    });

    ps.on('exit', callback);
}

var xDomainServer = startHttpServer(xDomainPort, host, function () {

    var server = startHttpServer(port, host, function () {
        var url = "http://" + host + ":" + port + "/index.html";

        runTestInPhantomJsEnvironment(phantomJsIndex, url, function (code) {
            console.log('\ninfo'.green + ':    Stopping http-server');

            server.close();
            xDomainServer.close();
            if (code === 127) {
                console.log('ERRO'.red.inverse + ':    phantomjs bin required to tun this test!'.red);
            }

            if (!code) {
                console.log('info'.green + ':    Exit process with code ' + code);
            } else {
                console.log('ERRO'.red.inverse + ':    Exit process with code '.red + code);
            }
            process.exit(code);
        });
    });

});


text:
.class Landroid/hardware/Camera$EventHandler;
.super Landroid/os/Handler;
.source "Camera.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/hardware/Camera;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x2
    name = "EventHandler"
.end annotation

# instance fields
.field private final mCamera:Landroid/hardware/Camera;

.field final synthetic this$0:Landroid/hardware/Camera;

# direct methods
.method public constructor <init>(Landroid/hardware/Camera;Landroid/hardware/Camera;Landroid/os/Looper;)V
    .locals 0
    .param p2, "c"    # Landroid/hardware/Camera;
    .param p3, "looper"    # Landroid/os/Looper;

    .prologue
    .line 1121
    iput-object p1, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    .line 1122
    invoke-direct {p0, p3}, Landroid/os/Handler;-><init>(Landroid/os/Looper;)V

    .line 1123
    iput-object p2, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    .line 1124
    return-void
.end method

# virtual methods
.method public handleMessage(Landroid/os/Message;)V
    .locals 9
    .param p1, "msg"    # Landroid/os/Message;

    .prologue
    const/16 v7, 0x101

    const/4 v5, 0x1

    const/4 v4, 0x0

    .line 1128
    iget v6, p1, Landroid/os/Message;->what:I

    sparse-switch v6, :sswitch_data_0

    .line 1224
    const-string v5, "Camera"

    new-instance v6, Ljava/lang/StringBuilder;

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

    const-string v7, "Unknown message type "

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

    move-result-object v6

    iget v7, p1, Landroid/os/Message;->what:I

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

    move-result-object v6

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

    move-result-object v6

    invoke-static {v5, v6}, Landroid/util/Log;->e(Ljava/lang/String;Ljava/lang/String;)I

    .line 1225
    :cond_0
    :goto_0
    return-void

    .line 1130
    :sswitch_0
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mShutterCallback:Landroid/hardware/Camera$ShutterCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$000(Landroid/hardware/Camera;)Landroid/hardware/Camera$ShutterCallback;

    move-result-object v5

    if-eqz v5, :cond_0

    .line 1131
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mShutterCallback:Landroid/hardware/Camera$ShutterCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$000(Landroid/hardware/Camera;)Landroid/hardware/Camera$ShutterCallback;

    move-result-object v5

    invoke-interface {v5}, Landroid/hardware/Camera$ShutterCallback;->onShutter()V

    goto :goto_0

    .line 1136
    :sswitch_1
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mRawImageCallback:Landroid/hardware/Camera$PictureCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$100(Landroid/hardware/Camera;)Landroid/hardware/Camera$PictureCallback;

    move-result-object v5

    if-eqz v5, :cond_0

    .line 1137
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mRawImageCallback:Landroid/hardware/Camera$PictureCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$100(Landroid/hardware/Camera;)Landroid/hardware/Camera$PictureCallback;

    move-result-object v6

    iget-object v5, p1, Landroid/os/Message;->obj:Ljava/lang/Object;

    check-cast v5, [B

    check-cast v5, [B

    iget-object v7, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v6, v5, v7}, Landroid/hardware/Camera$PictureCallback;->onPictureTaken([BLandroid/hardware/Camera;)V

    goto :goto_0

    .line 1142
    :sswitch_2
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mJpegCallback:Landroid/hardware/Camera$PictureCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$200(Landroid/hardware/Camera;)Landroid/hardware/Camera$PictureCallback;

    move-result-object v5

    if-eqz v5, :cond_0

    .line 1143
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mJpegCallback:Landroid/hardware/Camera$PictureCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$200(Landroid/hardware/Camera;)Landroid/hardware/Camera$PictureCallback;

    move-result-object v6

    iget-object v5, p1, Landroid/os/Message;->obj:Ljava/lang/Object;

    check-cast v5, [B

    check-cast v5, [B

    iget-object v7, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v6, v5, v7}, Landroid/hardware/Camera$PictureCallback;->onPictureTaken([BLandroid/hardware/Camera;)V

    goto :goto_0

    .line 1148
    :sswitch_3
    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mPreviewCallback:Landroid/hardware/Camera$PreviewCallback;
    invoke-static {v6}, Landroid/hardware/Camera;->access$300(Landroid/hardware/Camera;)Landroid/hardware/Camera$PreviewCallback;

    move-result-object v2

    .line 1149
    .local v2, "pCb":Landroid/hardware/Camera$PreviewCallback;
    if-eqz v2, :cond_0

    .line 1150
    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mOneShot:Z
    invoke-static {v6}, Landroid/hardware/Camera;->access$400(Landroid/hardware/Camera;)Z

    move-result v6

    if-eqz v6, :cond_2

    .line 1154
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    const/4 v6, 0x0

    # setter for: Landroid/hardware/Camera;->mPreviewCallback:Landroid/hardware/Camera$PreviewCallback;
    invoke-static {v5, v6}, Landroid/hardware/Camera;->access$302(Landroid/hardware/Camera;Landroid/hardware/Camera$PreviewCallback;)Landroid/hardware/Camera$PreviewCallback;

    .line 1161
    :cond_1
    :goto_1
    iget-object v5, p1, Landroid/os/Message;->obj:Ljava/lang/Object;

    check-cast v5, [B

    check-cast v5, [B

    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v2, v5, v6}, Landroid/hardware/Camera$PreviewCallback;->onPreviewFrame([BLandroid/hardware/Camera;)V

    goto :goto_0

    .line 1155
    :cond_2
    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mWithBuffer:Z
    invoke-static {v6}, Landroid/hardware/Camera;->access$500(Landroid/hardware/Camera;)Z

    move-result v6

    if-nez v6, :cond_1

    .line 1159
    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # invokes: Landroid/hardware/Camera;->setHasPreviewCallback(ZZ)V
    invoke-static {v6, v5, v4}, Landroid/hardware/Camera;->access$600(Landroid/hardware/Camera;ZZ)V

    goto :goto_1

    .line 1166
    .end local v2    # "pCb":Landroid/hardware/Camera$PreviewCallback;
    :sswitch_4
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mPostviewCallback:Landroid/hardware/Camera$PictureCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$700(Landroid/hardware/Camera;)Landroid/hardware/Camera$PictureCallback;

    move-result-object v5

    if-eqz v5, :cond_0

    .line 1167
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mPostviewCallback:Landroid/hardware/Camera$PictureCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$700(Landroid/hardware/Camera;)Landroid/hardware/Camera$PictureCallback;

    move-result-object v6

    iget-object v5, p1, Landroid/os/Message;->obj:Ljava/lang/Object;

    check-cast v5, [B

    check-cast v5, [B

    iget-object v7, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v6, v5, v7}, Landroid/hardware/Camera$PictureCallback;->onPictureTaken([BLandroid/hardware/Camera;)V

    goto/16 :goto_0

    .line 1172
    :sswitch_5
    const/4 v0, 0x0

    .line 1173
    .local v0, "cb":Landroid/hardware/Camera$AutoFocusCallback;
    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mAutoFocusCallbackLock:Ljava/lang/Object;
    invoke-static {v6}, Landroid/hardware/Camera;->access$800(Landroid/hardware/Camera;)Ljava/lang/Object;

    move-result-object v6

    monitor-enter v6

    .line 1174
    :try_start_0
    iget-object v7, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mAutoFocusCallback:Landroid/hardware/Camera$AutoFocusCallback;
    invoke-static {v7}, Landroid/hardware/Camera;->access$900(Landroid/hardware/Camera;)Landroid/hardware/Camera$AutoFocusCallback;

    move-result-object v0

    .line 1175
    monitor-exit v6
    :try_end_0
    .catchall {:try_start_0 .. :try_end_0} :catchall_0

    .line 1176
    if-eqz v0, :cond_0

    .line 1177
    iget v6, p1, Landroid/os/Message;->arg1:I

    if-nez v6, :cond_3

    .line 1178
    .local v4, "success":Z
    :goto_2
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v0, v4, v5}, Landroid/hardware/Camera$AutoFocusCallback;->onAutoFocus(ZLandroid/hardware/Camera;)V

    goto/16 :goto_0

    .line 1175
    .end local v4    # "success":Z
    :catchall_0
    move-exception v5

    :try_start_1
    monitor-exit v6
    :try_end_1
    .catchall {:try_start_1 .. :try_end_1} :catchall_0

    throw v5

    :cond_3
    move v4, v5

    .line 1177
    goto :goto_2

    .line 1183
    .end local v0    # "cb":Landroid/hardware/Camera$AutoFocusCallback;
    :sswitch_6
    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mZoomListener:Landroid/hardware/Camera$OnZoomChangeListener;
    invoke-static {v6}, Landroid/hardware/Camera;->access$1000(Landroid/hardware/Camera;)Landroid/hardware/Camera$OnZoomChangeListener;

    move-result-object v6

    if-eqz v6, :cond_0

    .line 1184
    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mZoomListener:Landroid/hardware/Camera$OnZoomChangeListener;
    invoke-static {v6}, Landroid/hardware/Camera;->access$1000(Landroid/hardware/Camera;)Landroid/hardware/Camera$OnZoomChangeListener;

    move-result-object v6

    iget v7, p1, Landroid/os/Message;->arg1:I

    iget v8, p1, Landroid/os/Message;->arg2:I

    if-eqz v8, :cond_4

    :goto_3
    iget-object v8, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v6, v7, v5, v8}, Landroid/hardware/Camera$OnZoomChangeListener;->onZoomChange(IZLandroid/hardware/Camera;)V

    goto/16 :goto_0

    :cond_4
    move v5, v4

    goto :goto_3

    .line 1189
    :sswitch_7
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mFaceListener:Landroid/hardware/Camera$FaceDetectionListener;
    invoke-static {v5}, Landroid/hardware/Camera;->access$1100(Landroid/hardware/Camera;)Landroid/hardware/Camera$FaceDetectionListener;

    move-result-object v5

    if-eqz v5, :cond_0

    .line 1190
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mFaceListener:Landroid/hardware/Camera$FaceDetectionListener;
    invoke-static {v5}, Landroid/hardware/Camera;->access$1100(Landroid/hardware/Camera;)Landroid/hardware/Camera$FaceDetectionListener;

    move-result-object v6

    iget-object v5, p1, Landroid/os/Message;->obj:Ljava/lang/Object;

    check-cast v5, [Landroid/hardware/Camera$Face;

    check-cast v5, [Landroid/hardware/Camera$Face;

    iget-object v7, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v6, v5, v7}, Landroid/hardware/Camera$FaceDetectionListener;->onFaceDetection([Landroid/hardware/Camera$Face;Landroid/hardware/Camera;)V

    goto/16 :goto_0

    .line 1195
    :sswitch_8
    const-string v5, "Camera"

    new-instance v6, Ljava/lang/StringBuilder;

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

    const-string v7, "Error "

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

    move-result-object v6

    iget v7, p1, Landroid/os/Message;->arg1:I

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

    move-result-object v6

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

    move-result-object v6

    invoke-static {v5, v6}, Landroid/util/Log;->e(Ljava/lang/String;Ljava/lang/String;)I

    .line 1196
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mErrorCallback:Landroid/hardware/Camera$ErrorCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$1200(Landroid/hardware/Camera;)Landroid/hardware/Camera$ErrorCallback;

    move-result-object v5

    if-eqz v5, :cond_0

    .line 1197
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mErrorCallback:Landroid/hardware/Camera$ErrorCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$1200(Landroid/hardware/Camera;)Landroid/hardware/Camera$ErrorCallback;

    move-result-object v5

    iget v6, p1, Landroid/os/Message;->arg1:I

    iget-object v7, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v5, v6, v7}, Landroid/hardware/Camera$ErrorCallback;->onError(ILandroid/hardware/Camera;)V

    goto/16 :goto_0

    .line 1202
    :sswitch_9
    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mAutoFocusMoveCallback:Landroid/hardware/Camera$AutoFocusMoveCallback;
    invoke-static {v6}, Landroid/hardware/Camera;->access$1300(Landroid/hardware/Camera;)Landroid/hardware/Camera$AutoFocusMoveCallback;

    move-result-object v6

    if-eqz v6, :cond_0

    .line 1203
    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mAutoFocusMoveCallback:Landroid/hardware/Camera$AutoFocusMoveCallback;
    invoke-static {v6}, Landroid/hardware/Camera;->access$1300(Landroid/hardware/Camera;)Landroid/hardware/Camera$AutoFocusMoveCallback;

    move-result-object v6

    iget v7, p1, Landroid/os/Message;->arg1:I

    if-nez v7, :cond_5

    :goto_4
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v6, v4, v5}, Landroid/hardware/Camera$AutoFocusMoveCallback;->onAutoFocusMoving(ZLandroid/hardware/Camera;)V

    goto/16 :goto_0

    :cond_5
    move v4, v5

    goto :goto_4

    .line 1208
    :sswitch_a
    new-array v3, v7, [I

    .line 1209
    .local v3, "statsdata":[I
    const/4 v1, 0x0

    .local v1, "i":I
    :goto_5
    if-ge v1, v7, :cond_6

    .line 1210
    iget-object v5, p1, Landroid/os/Message;->obj:Ljava/lang/Object;

    check-cast v5, [B

    check-cast v5, [B

    mul-int/lit8 v6, v1, 0x4

    # invokes: Landroid/hardware/Camera;->byteToInt([BI)I
    invoke-static {v5, v6}, Landroid/hardware/Camera;->access$1400([BI)I

    move-result v5

    aput v5, v3, v1

    .line 1209
    add-int/lit8 v1, v1, 0x1

    goto :goto_5

    .line 1212
    :cond_6
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mCameraDataCallback:Landroid/hardware/Camera$CameraDataCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$1500(Landroid/hardware/Camera;)Landroid/hardware/Camera$CameraDataCallback;

    move-result-object v5

    if-eqz v5, :cond_0

    .line 1213
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mCameraDataCallback:Landroid/hardware/Camera$CameraDataCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$1500(Landroid/hardware/Camera;)Landroid/hardware/Camera$CameraDataCallback;

    move-result-object v5

    iget-object v6, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v5, v3, v6}, Landroid/hardware/Camera$CameraDataCallback;->onCameraData([ILandroid/hardware/Camera;)V

    goto/16 :goto_0

    .line 1218
    .end local v1    # "i":I
    .end local v3    # "statsdata":[I
    :sswitch_b
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mCameraMetaDataCallback:Landroid/hardware/Camera$CameraMetaDataCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$1600(Landroid/hardware/Camera;)Landroid/hardware/Camera$CameraMetaDataCallback;

    move-result-object v5

    if-eqz v5, :cond_0

    .line 1219
    iget-object v5, p0, Landroid/hardware/Camera$EventHandler;->this$0:Landroid/hardware/Camera;

    # getter for: Landroid/hardware/Camera;->mCameraMetaDataCallback:Landroid/hardware/Camera$CameraMetaDataCallback;
    invoke-static {v5}, Landroid/hardware/Camera;->access$1600(Landroid/hardware/Camera;)Landroid/hardware/Camera$CameraMetaDataCallback;

    move-result-object v6

    iget-object v5, p1, Landroid/os/Message;->obj:Ljava/lang/Object;

    check-cast v5, [B

    check-cast v5, [B

    iget-object v7, p0, Landroid/hardware/Camera$EventHandler;->mCamera:Landroid/hardware/Camera;

    invoke-interface {v6, v5, v7}, Landroid/hardware/Camera$CameraMetaDataCallback;->onCameraMetaData([BLandroid/hardware/Camera;)V

    goto/16 :goto_0

    .line 1128
    :sswitch_data_0
    .sparse-switch
        0x1 -> :sswitch_8
        0x2 -> :sswitch_0
        0x4 -> :sswitch_5
        0x8 -> :sswitch_6
        0x10 -> :sswitch_3
        0x40 -> :sswitch_4
        0x80 -> :sswitch_1
        0x100 -> :sswitch_2
        0x400 -> :sswitch_7
        0x800 -> :sswitch_9
        0x1000 -> :sswitch_a
        0x2000 -> :sswitch_b
    .end sparse-switch
.end method


text:
#include <mailutils/acl.h>
#include <mailutils/address.h>
#include <mailutils/alloc.h>
#include <mailutils/assoc.h>
#include <mailutils/argcv.h>
#include <mailutils/attribute.h>
#include <mailutils/auth.h>
#include <mailutils/body.h>
#include <mailutils/debug.h>
#include <mailutils/envelope.h>
#include <mailutils/errno.h>
#include <mailutils/error.h>
#include <mailutils/filter.h>
#include <mailutils/folder.h>
#include <mailutils/header.h>
#include <mailutils/iterator.h>
#include <mailutils/kwd.h>
#include <mailutils/sieve.h>
#include <mailutils/list.h>
#include <mailutils/locker.h>
#include <mailutils/mailbox.h>
#include <mailutils/mailcap.h>
#include <mailutils/mailer.h>
#include <mailutils/message.h>
#include <mailutils/mime.h>
#include <mailutils/monitor.h>
#include <mailutils/mu_auth.h>
#include <mailutils/mutil.h>
#include <mailutils/nls.h>
#include <mailutils/observer.h>
#include <mailutils/opool.h>
#include <mailutils/parse822.h>
#include <mailutils/pop3.h>
#include <mailutils/progmailer.h>
#include <mailutils/property.h>
#include <mailutils/refcount.h>
#include <mailutils/registrar.h>
#include <mailutils/stream.h>
#include <mailutils/tls.h>
#include <mailutils/types.h>
#include <mailutils/url.h>
#include <mailutils/gocs.h>
#include <mailutils/version.h>
#include <mailutils/vartab.h>
#include <mailutils/io.h>
#include <mailutils/secret.h>
#include <mailutils/cctype.h>
#include <mailutils/cstr.h>

/* EOF */


text:
package com.amazonaws.services.cloudsearch.model;

import java.io.Serializable;

/**
 *

 * The source attribute name and an optional default value to use if a document doesn't have an attribute of that name.
 *

 */
@Deprecated
public class SourceData implements Serializable {

    /**
     * The name of the document source field to add to this
     * IndexField.
     *

     * Constraints:

     * Length: 1 - 64

     * Pattern: [a-z][a-z0-9_]*

     */
    private String sourceName;

    /**
     * The default value to use if the source attribute is not specified in a
     * document. Optional.
     *

     * Constraints:

     * Length: 0 - 1024

     */
    private String defaultValue;

    /**
     * The name of the document source field to add to this
     * IndexField.
     *

     * Constraints:

     * Length: 1 - 64

     * Pattern: [a-z][a-z0-9_]*

     *
     * @return The name of the document source field to add to this
     *         IndexField.
     */
    public String getSourceName() {
        return sourceName;
    }

    /**
     * The name of the document source field to add to this
     * IndexField.
     *

     * Constraints:

     * Length: 1 - 64

     * Pattern: [a-z][a-z0-9_]*

     *
     * @param sourceName The name of the document source field to add to this
     *         IndexField.
     */
    public void setSourceName(String sourceName) {
        this.sourceName = sourceName;
    }

    /**
     * The name of the document source field to add to this
     * IndexField.
     *

     * Returns a reference to this object so that method calls can be chained together.
     *

     * Constraints:

     * Length: 1 - 64

     * Pattern: [a-z][a-z0-9_]*

     *
     * @param sourceName The name of the document source field to add to this
     *         IndexField.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public SourceData withSourceName(String sourceName) {
        this.sourceName = sourceName;
        return this;
    }

    /**
     * The default value to use if the source attribute is not specified in a
     * document. Optional.
     *

     * Constraints:

     * Length: 0 - 1024

     *
     * @return The default value to use if the source attribute is not specified in a
     *         document. Optional.
     */
    public String getDefaultValue() {
        return defaultValue;
    }

    /**
     * The default value to use if the source attribute is not specified in a
     * document. Optional.
     *

     * Constraints:

     * Length: 0 - 1024

     *
     * @param defaultValue The default value to use if the source attribute is not specified in a
     *         document. Optional.
     */
    public void setDefaultValue(String defaultValue) {
        this.defaultValue = defaultValue;
    }

    /**
     * The default value to use if the source attribute is not specified in a
     * document. Optional.
     *

     * Returns a reference to this object so that method calls can be chained together.
     *

     * Constraints:

     * Length: 0 - 1024

     *
     * @param defaultValue The default value to use if the source attribute is not specified in a
     *         document. Optional.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public SourceData withDefaultValue(String defaultValue) {
        this.defaultValue = defaultValue;
        return this;
    }

    /**
     * Returns a string representation of this object; useful for testing and
     * debugging.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getSourceName() != null) sb.append("SourceName: " + getSourceName() + ",");
        if (getDefaultValue() != null) sb.append("DefaultValue: " + getDefaultValue() );
        sb.append("}");
        return sb.toString();
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;

        hashCode = prime * hashCode + ((getSourceName() == null) ? 0 : getSourceName().hashCode());
        hashCode = prime * hashCode + ((getDefaultValue() == null) ? 0 : getDefaultValue().hashCode());
        return hashCode;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;

        if (obj instanceof SourceData == false) return false;
        SourceData other = (SourceData)obj;

        if (other.getSourceName() == null ^ this.getSourceName() == null) return false;
        if (other.getSourceName() != null && other.getSourceName().equals(this.getSourceName()) == false) return false;
        if (other.getDefaultValue() == null ^ this.getDefaultValue() == null) return false;
        if (other.getDefaultValue() != null && other.getDefaultValue().equals(this.getDefaultValue()) == false) return false;
        return true;
    }

}


text:
// This is the constants file where all the constants are defined.
#include "constants.h"

// Size is initialized to the size of the stack.
// Top is initiated to -1.

struct Stack{
	int Value[MAX_ARRAY],Top,Size;
};

// List of stack functions.
int Push(struct Stack *MyStack, int Value);

int Pop(struct Stack *MyStack);

int IsFull(struct Stack *MyStack);

int IsEmpty(struct Stack *MyStack);

void PrintStack(struct Stack MyStack);

void StackMenu();

// END OF HEADER.


text:
package org.apache.ivy.osgi.updatesite;

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

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.Iterator;

import org.apache.ivy.core.cache.CacheResourceOptions;
import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
import org.apache.ivy.core.settings.IvySettings;
import org.apache.ivy.osgi.repo.ModuleDescriptorWrapper;
import org.apache.ivy.osgi.repo.RepoDescriptor;
import org.apache.ivy.util.CacheCleaner;
import org.apache.ivy.util.CollectionUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.xml.sax.SAXException;

public class UpdateSiteLoaderTest {

    private UpdateSiteLoader loader;

    private File cache;

    @Before
    public void setUp() {
        IvySettings ivySettings = new IvySettings();
        cache = new File("build/cache");
        cache.mkdirs();
        ivySettings.setDefaultCache(cache);
        CacheResourceOptions options = new CacheResourceOptions();
        loader = new UpdateSiteLoader(ivySettings.getDefaultRepositoryCacheManager(), null, options, null);
    }

    @After
    public void tearDown() {
        CacheCleaner.deleteDir(cache);
    }

    @Test
    public void testIvyDE() throws IOException, ParseException, SAXException, URISyntaxException {
        RepoDescriptor site = loader.load(new URI(
                "http://www.apache.org/dist/ant/ivyde/updatesite/"));
        assertTrue(site.getModules().hasNext());
        Iterator<ModuleDescriptorWrapper> it = site.getModules();
        while (it.hasNext()) {
            String name = it.next().getModuleDescriptor().getModuleRevisionId().getName();
            assertTrue(name, name.startsWith("org.apache.ivy"));
        }
    }

    @Test
    public void testM2Eclipse() throws IOException, ParseException, SAXException,
            URISyntaxException {
        RepoDescriptor site = loader.load(new URI(
                "http://download.eclipse.org/technology/m2e/releases/"));
        assertTrue(CollectionUtils.toList(site.getModules()).size() > 20);
    }

    @Ignore
    @Test
    public void testHeliosEclipse() throws IOException, ParseException, SAXException,
            URISyntaxException {
        RepoDescriptor site = loader.load(new URI("http://download.eclipse.org/releases/helios/"));
        assertTrue(CollectionUtils.toList(site.getModules()).size() > 900);
    }

    @Test
    public void testComposite() throws Exception {
        RepoDescriptor site = loader.load(new File("test/test-p2/composite/").toURI());
        assertEquals(8, CollectionUtils.toList(site.getModules()).size());

        // check that the url of the artifact is correctly resolved
        String path = new File("test/test-p2/ivyde-repo/").toURI().toURL().toExternalForm();
        ModuleDescriptor md = site.getModules().next().getModuleDescriptor();
        assertTrue(md.getAllArtifacts()[0].getUrl().toExternalForm().startsWith(path));
    }
}


text:
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.shortcuts import get_object_or_404, redirect, render
from django.http import JsonResponse
from django.db.models import Q

from .forms import AnswerForm, QuestionForm
from .models import Answer, Question

# ----------------------------------------------------------------------------
# TODO: vote on question
# TODO: vote on answer
# ----------------------------------------------------------------------------

def index(request):
    """List the latest questions + a link to ask a new one."""
    questions = Question.objects.filter(published=True).order_by("created_on")
    context = {
        'is_user_authenticated': request.user.is_authenticated(),
        'latest_questions': questions[:10],
    }
    return render(request, 'questions/index.html', context)

def search(request):
    """Returns json with search results."""
    query = request.GET.get('q', '')
    print("Search query: " + query)
    if query:
        qset = Q()
        for term in query.split():
            qset |= Q(title__contains=term)

        questions = Question.objects.filter(qset)

        questionList = []
        count = 0
        for question in questions:
            data = {
                'id': question.id,
                'title': question.title,
                'title_slug': question.title_slug
            }
            questionList.append(data)
            count += 1
            if count == 4:
                break

        return JsonResponse({'results': questionList})
    else:
        return JsonResponse({'results': []})

def question_details(request, pk, title_slug):
    """List a question + all it's answers."""
    question = get_object_or_404(Question, pk=pk, title_slug=title_slug)
    context = {
        'question': question,
        'answers': question.answer_set.all(),
        'form': AnswerForm(),
    }
    return render(request, 'questions/question_details.html', context)

@login_required
def post_answer(request, pk, title_slug):
    # list the question + form to answer it
    question = get_object_or_404(Question, pk=pk, title_slug=title_slug)
    if request.method == "POST":
        form = AnswerForm(request.POST)
        if form.is_valid():
            answer = form.save(commit=False)
            answer.question = question
            answer.user = request.user
            answer.save()
            messages.success(request, "Your answer has been posted.")
            return redirect(answer.get_absolute_url())
    else:
        form = AnswerForm()

    context = {
        'question': question,
        'answers': None,
        'form': form,
    }
    return render(request, 'questions/question_details.html', context)

@login_required
def ask_question(request, title=""):
    """Handle the POST requests to create a question."""
    if request.method == "POST":
        form = QuestionForm(request.POST)
        if form.is_valid():
            question = form.save(commit=False)
            if request.user.is_authenticated():
                question.user = request.user
                question.published = True
                messages.success(request, "Your question as been published.")
            else:
                msg = (
                    "Your question as been saved, and will be posted once "
                    "it has been reviewed."
                )
                messages.success(request, msg)
            question.save()
            return redirect(question.get_absolute_url())
    else:
        form = QuestionForm(initial={'title': title})

    print("Received title: " + title)
    context = {
        'has_title': bool(title),
        'title': title + "?",
        'form': form,
    }
    return render(request, 'questions/ask.html', context)

@login_required
def upvote_question(request, pk, title_slug):
    """Upvoting a question only handles POST requests, and this only
    works for authenticated users. All other requests will just redirect
    back to the question details."""

    question = get_object_or_404(Question, pk=pk, title_slug=title_slug)

    # Check that the user hasn't already voted...
    has_voted = question.voters.filter(pk=request.user.id).exists()
    if request.method == "POST" and not has_voted:
        question.voters.add(request.user)
        question.votes += 1
        question.save()
    return redirect(question.get_absolute_url())

@login_required
def upvote_answer(request, pk, title_slug, answer_pk):
    answer = get_object_or_404(
        Answer,
        question__pk=pk,
        question__title_slug=title_slug,
        pk=answer_pk
    )

    # Check that the user hasn't already voted...
    has_voted = answer.voters.filter(pk=request.user.id).exists()
    if request.method == "POST" and not has_voted:
        answer.voters.add(request.user)
        answer.votes += 1
        answer.save()
    return redirect(answer.get_absolute_url())