text:
/*
* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
* THIS FILE MUST NOT BE EDITED BY HAND
 */

package assert

import (
	http "net/http"
	url "net/url"
	time "time"
)

// Condition uses a Comparison to assert a complex condition.
func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
	return Condition(a.t, comp, msgAndArgs...)
}

// Contains asserts that the specified string, list(array, slice...) or map contains the
// specified substring or element.
//
//    a.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
//    a.Contains(["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
//    a.Contains({"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
	return Contains(a.t, s, contains, msgAndArgs...)
}

// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
//  a.Empty(obj)
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
	return Empty(a.t, object, msgAndArgs...)
}

// Equal asserts that two objects are equal.
//
//    a.Equal(123, 123, "123 and 123 should be equal")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
	return Equal(a.t, expected, actual, msgAndArgs...)
}

// EqualError asserts that a function returned an error (i.e. not `nil`)
// and that it is equal to the provided error.
//
//   actualObj, err := SomeFunction()
//   if assert.Error(t, err, "An error was expected") {
// 	   assert.Equal(t, err, expectedError)
//   }
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
	return EqualError(a.t, theError, errString, msgAndArgs...)
}

// EqualValues asserts that two objects are equal or convertable to the same types
// and equal.
//
//    a.EqualValues(uint32(123), int32(123), "123 and 123 should be equal")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
	return EqualValues(a.t, expected, actual, msgAndArgs...)
}

// Error asserts that a function returned an error (i.e. not `nil`).
//
//   actualObj, err := SomeFunction()
//   if a.Error(err, "An error was expected") {
// 	   assert.Equal(t, err, expectedError)
//   }
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool {
	return Error(a.t, err, msgAndArgs...)
}

// Exactly asserts that two objects are equal is value and type.
//
//    a.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
	return Exactly(a.t, expected, actual, msgAndArgs...)
}

// Fail reports a failure through
func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
	return Fail(a.t, failureMessage, msgAndArgs...)
}

// FailNow fails test
func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool {
	return FailNow(a.t, failureMessage, msgAndArgs...)
}

// False asserts that the specified value is false.
//
//    a.False(myBool, "myBool should be false")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
	return False(a.t, value, msgAndArgs...)
}

// HTTPBodyContains asserts that a specified handler returns a
// body that contains a string.
//
//  a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
	return HTTPBodyContains(a.t, handler, method, url, values, str)
}

// HTTPBodyNotContains asserts that a specified handler returns a
// body that does not contain a string.
//
//  a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
	return HTTPBodyNotContains(a.t, handler, method, url, values, str)
}

// HTTPError asserts that a specified handler returns an error status code.
//
//  a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) bool {
	return HTTPError(a.t, handler, method, url, values)
}

// HTTPRedirect asserts that a specified handler returns a redirect status code.
//
//  a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) bool {
	return HTTPRedirect(a.t, handler, method, url, values)
}

// HTTPSuccess asserts that a specified handler returns a success status code.
//
//  a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) bool {
	return HTTPSuccess(a.t, handler, method, url, values)
}

// Implements asserts that an object is implemented by the specified interface.
//
//    a.Implements((*MyInterface)(nil), new(MyObject), "MyObject")
func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
	return Implements(a.t, interfaceObject, object, msgAndArgs...)
}

// InDelta asserts that the two numerals are within delta of each other.
//
// 	 a.InDelta(math.Pi, (22 / 7.0), 0.01)
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
	return InDelta(a.t, expected, actual, delta, msgAndArgs...)
}

// InDeltaSlice is the same as InDelta, except it compares two slices.
func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
	return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
}

// InEpsilon asserts that expected and actual have a relative error less than epsilon
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
	return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
}

// InEpsilonSlice is the same as InEpsilon, except it compares two slices.
func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
	return InEpsilonSlice(a.t, expected, actual, delta, msgAndArgs...)
}

// IsType asserts that the specified objects are of the same type.
func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
	return IsType(a.t, expectedType, object, msgAndArgs...)
}

// JSONEq asserts that two JSON strings are equivalent.
//
//  a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool {
	return JSONEq(a.t, expected, actual, msgAndArgs...)
}

// Len asserts that the specified object has specific length.
// Len also fails if the object has a type that len() not accept.
//
//    a.Len(mySlice, 3, "The size of slice is not 3")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
	return Len(a.t, object, length, msgAndArgs...)
}

// Nil asserts that the specified object is nil.
//
//    a.Nil(err, "err should be nothing")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
	return Nil(a.t, object, msgAndArgs...)
}

// NoError asserts that a function returned no error (i.e. `nil`).
//
//   actualObj, err := SomeFunction()
//   if a.NoError(err) {
// 	   assert.Equal(t, actualObj, expectedObj)
//   }
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
	return NoError(a.t, err, msgAndArgs...)
}

// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
// specified substring or element.
//
//    a.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
//    a.NotContains(["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
//    a.NotContains({"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
	return NotContains(a.t, s, contains, msgAndArgs...)
}

// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
// a slice or a channel with len == 0.
//
//  if a.NotEmpty(obj) {
//    assert.Equal(t, "two", obj[1])
//  }
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
	return NotEmpty(a.t, object, msgAndArgs...)
}

// NotEqual asserts that the specified values are NOT equal.
//
//    a.NotEqual(obj1, obj2, "two objects shouldn't be equal")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
	return NotEqual(a.t, expected, actual, msgAndArgs...)
}

// NotNil asserts that the specified object is not nil.
//
//    a.NotNil(err, "err should be something")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
	return NotNil(a.t, object, msgAndArgs...)
}

// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
//
//   a.NotPanics(func(){
//     RemainCalm()
//   }, "Calling RemainCalm() should NOT panic")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
	return NotPanics(a.t, f, msgAndArgs...)
}

// NotRegexp asserts that a specified regexp does not match a string.
//
//  a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
//  a.NotRegexp("^start", "it's not starting")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
	return NotRegexp(a.t, rx, str, msgAndArgs...)
}

// NotZero asserts that i is not the zero value for its type and returns the truth.
func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool {
	return NotZero(a.t, i, msgAndArgs...)
}

// Panics asserts that the code inside the specified PanicTestFunc panics.
//
//   a.Panics(func(){
//     GoCrazy()
//   }, "Calling GoCrazy() should panic")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
	return Panics(a.t, f, msgAndArgs...)
}

// Regexp asserts that a specified regexp matches a string.
//
//  a.Regexp(regexp.MustCompile("start"), "it's starting")
//  a.Regexp("start...$", "it's not starting")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
	return Regexp(a.t, rx, str, msgAndArgs...)
}

// True asserts that the specified value is true.
//
//    a.True(myBool, "myBool should be true")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
	return True(a.t, value, msgAndArgs...)
}

// WithinDuration asserts that the two times are within duration delta of each other.
//
//   a.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
//
// Returns whether the assertion was successful (true) or not (false).
func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
	return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
}

// Zero asserts that i is the zero value for its type and returns the truth.
func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool {
	return Zero(a.t, i, msgAndArgs...)
}


text:
package oldapi;

import java.io.IOException;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;

public class Average
{
	public static void main(String[] args) throws IOException
	{
		if (args.length != 2)
		{
			System.err.println("Usage: Average <input path> <output path>");
			System.exit(-1);
		}

		JobConf conf = new JobConf(Average.class);
		conf.setJobName("Average temperature");
		FileInputFormat.addInputPath(conf, new Path(args[0]));
		FileOutputFormat.setOutputPath(conf, new Path(args[1]));
		conf.setMapperClass(AverageMapper.class);
		conf.setReducerClass(AverageReducer.class);
		conf.setOutputKeyClass(Text.class);
		conf.setOutputValueClass(DoubleWritable.class);
		JobClient.runJob(conf);
	}
}

redpajama_set_name: RedPajamaGithub


text:
import java.util.*;
import java.io.*;
import java.awt.*;

public class stdtest{
	  public static void main(String[] args) throws InterruptedException {
    StdDraw.setXScale(10);
    StdDraw.setYScale(10);
		Color[] colors = {StdDraw.BLUE, StdDraw.CYAN, StdDraw.GRAY, StdDraw.GREEN};
		while(true){
		Random rand = new Random();
		double  n1 = rand.nextInt(1000) + 1;
		double  n2 = rand.nextInt(1000) + 1;
		double  n3 = rand.nextInt(1000) + 1;

		/*System.out.println(n1);
		System.out.println(n2);
		System.out.println(n3);*/
		double randnum1 = n1/1000;
		double randnum2 = n2/1000;
		double randnum3 = n3/1000;
		/*System.out.println(randnum1);
		System.out.println(randnum2);
		System.out.println(randnum3);*/
		int i = rand.nextInt(3)+0;
		StdDraw.setPenColor(colors[i]);
	    StdDraw.filledCircle(randnum1,randnum2,randnum3);
	    Thread.sleep(1000);
	    StdDraw.clear();
		}
	  }
}


text: export { ChildSigninCardModule } from './child-signin-card.module';


text:
/** \file stlsoft/meta/typefixer/iterator.hpp
 *
 * \brief [C++ only] Definition of the stlsoft::typefixer::iterator
 *   typefixer class template
 *   (\ref group__library__meta "Template Meta-programming" Library).
 */

#ifndef STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_ITERATOR
#define STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_ITERATOR

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
# define STLSOFT_VER_STLSOFT_META_TYPEFIXER_ITERATOR_MAJOR      2
# define STLSOFT_VER_STLSOFT_META_TYPEFIXER_ITERATOR_MINOR      0
# define STLSOFT_VER_STLSOFT_META_TYPEFIXER_ITERATOR_REVISION   1
# define STLSOFT_VER_STLSOFT_META_TYPEFIXER_ITERATOR_EDIT       20
#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////
 * Auto-generation and compatibility
 */

/*
[<[STLSOFT-AUTO:NO-UNITTEST]>]
[Incompatibilies-start]
STLSOFT_COMPILER_IS_MSVC: _MSC_VER < 1310
[Incompatibilies-end]
*/

/* /////////////////////////////////////////////////////////////////////////
 * Includes
 */

#ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
# include <stlsoft/stlsoft.h>
#endif /* !STLSOFT_INCL_STLSOFT_H_STLSOFT */

#ifndef STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT
# error stlsoft/typefixer/iterator.hpp is only compatible with compilers that support partial template specialisation
#endif /* !STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT */

/* /////////////////////////////////////////////////////////////////////////
 * Namespace
 */

#ifndef _STLSOFT_NO_NAMESPACE
namespace stlsoft
{

namespace typefixer
{
#endif /* _STLSOFT_NO_NAMESPACE */

/* /////////////////////////////////////////////////////////////////////////
 * Classes
 */

/** \brief Type-fixer for \c iterator member type
 *
 * \ingroup group__library__meta
 *
 * If type \c T has a \c iterator member type, then the type of
 * fixer_iterator<T>::iterator is
 * T::iterator, otherwise it is \c void
 */

template <ss_typename_param_k T, ss_bool_t>
struct fixer_iterator
{
    typedef ss_typename_type_k T::iterator      iterator;
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

// When not present it uses void as a placeholder
template <ss_typename_param_k T>
struct fixer_iterator<T, false>
{
    typedef void                                iterator;
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/** \brief Type-fixer for \c const_iterator member type
 *
 * \ingroup group__library__meta
 *
 * If type \c T has a \c const_iterator member type, then the type of
 * fixer_const_iterator<T>::const_iterator is
 * T::const_iterator, otherwise it is \c void
 */

template <ss_typename_param_k T, ss_bool_t>
struct fixer_const_iterator
{
    typedef ss_typename_type_k T::const_iterator    const_iterator;
};

#ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION

// When not present it uses void as a placeholder
template <ss_typename_param_k T>
struct fixer_const_iterator<T, false>
{
    typedef void                                    const_iterator;
};

#endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */

/* ////////////////////////////////////////////////////////////////////// */

#ifndef _STLSOFT_NO_NAMESPACE
} // namespace typefixer

} // namespace stlsoft
#endif /* _STLSOFT_NO_NAMESPACE */

/* ////////////////////////////////////////////////////////////////////// */

#endif /* !STLSOFT_INCL_STLSOFT_META_TYPEFIXER_HPP_ITERATOR */

/* ///////////////////////////// end of file //////////////////////////// */


text:
package com.github.liosha2007.android.library.common;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * @author Aleksey Permyakov (20.01.2015).
 */
public class IOStream extends ByteArrayOutputStream implements AutoCloseable {
    private ByteArrayInputStream inputStream = null;

    public IOStream() {
        super();
    }

    public IOStream(byte[] data) {
        this();
        inputStream = new ByteArrayInputStream(data);
    }

    @Override
    public void close() throws IOException {
        if (inputStream != null) {
            inputStream.close();
        }
        super.close();
    }

    public ByteArrayInputStream getInputStream() throws Exception {
        if (inputStream != null) {
            inputStream.close();
        }
        return (inputStream = new ByteArrayInputStream(super.toByteArray()));
    }
}


text:
<?php

namespace App\View;

use WhiteOctober\PagerfantaBundle\View\TwitterBootstrap4TranslatedView;

/**
 * SemanticUiTranslatedView.
 *
 * This view renders the semantic ui view with the text translated.
 */
class FrontendTranslatedView extends TwitterBootstrap4TranslatedView
{
    protected function buildPreviousMessage($text)
    {
        return sprintf('%s', $text);
    }

    protected function buildNextMessage($text)
    {
        return sprintf('%s', $text);
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return 'frontend_translated';
    }
}


text:
robbie speech
======

source file for Robbie the Robot's Brain
this package will take a text sentance process
with NLTK and map to a action


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

import com.facebook.presto.spi.function.ScalarFunction;
import com.facebook.presto.spi.function.SqlType;
import com.facebook.presto.spi.type.StandardTypes;
import com.facebook.presto.sql.analyzer.FeaturesConfig;
import com.facebook.presto.type.ArrayType;
import com.google.common.collect.ImmutableList;
import io.airlift.slice.Slice;
import io.airlift.slice.Slices;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;

import java.util.ArrayList;
import java.util.List;

import static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT;
import static com.facebook.presto.spi.type.BooleanType.BOOLEAN;
import static com.facebook.presto.spi.type.VarcharType.createUnboundedVarcharType;
import static com.facebook.presto.spi.type.VarcharType.createVarcharType;
import static com.facebook.presto.sql.analyzer.RegexLibrary.JONI;
import static com.facebook.presto.sql.analyzer.RegexLibrary.RE2J;

public class TestRegexpFunctions
        extends AbstractTestFunctions
{
    private static final FeaturesConfig JONI_FEATURES_CONFIG = new FeaturesConfig()
            .setRegexLibrary(JONI);

    private static final FeaturesConfig RE2J_FEATURES_CONFIG = new FeaturesConfig()
            .setRegexLibrary(RE2J);

    @Factory(dataProvider = "featuresConfig")
    public TestRegexpFunctions(FeaturesConfig featuresConfig)
    {
        super(featuresConfig);
    }

    @BeforeClass
    public void setUp()
    {
        registerScalar(TestRegexpFunctions.class);
    }

    @DataProvider(name = "featuresConfig")
    public static Object[][] featuresConfigProvider()
    {
        return new Object[][] {new Object[] {JONI_FEATURES_CONFIG}, new Object[] {RE2J_FEATURES_CONFIG}};
    }

    @ScalarFunction(deterministic = false) // if not non-deterministic, constant folding code accidentally fix invalid characters
    @SqlType(StandardTypes.VARCHAR)
    public static Slice invalidUtf8()
    {
        return Slices.wrappedBuffer(new byte[] {
                // AAA\uD800AAAA\uDFFFAAA, D800 and DFFF are valid unicode code points, but not valid UTF8
                (byte) 0x41, 0x41, (byte) 0xed, (byte) 0xa0, (byte) 0x80, 0x41, 0x41,
                0x41, 0x41, (byte) 0xed, (byte) 0xbf, (byte) 0xbf, 0x41, 0x41, 0x41,
        });
    }

    @Test
    public void testRegexpLike()
    {
        // Tests that REGEXP_LIKE doesn't loop infinitely on invalid UTF-8 input. Return value is irrelevant.
        functionAssertions.tryEvaluate("REGEXP_LIKE(invalid_utf8(), invalid_utf8())", BOOLEAN);

        assertFunction("REGEXP_LIKE('Stephen', 'Ste(v|ph)en')", BOOLEAN, true);
        assertFunction("REGEXP_LIKE('Stevens', 'Ste(v|ph)en')", BOOLEAN, true);
        assertFunction("REGEXP_LIKE('Stephen', '^Ste(v|ph)en$')", BOOLEAN, true);
        assertFunction("REGEXP_LIKE('Stevens', '^Ste(v|ph)en$')", BOOLEAN, false);

        assertFunction("REGEXP_LIKE('hello world', '[a-z]')", BOOLEAN, true);
        assertFunction("REGEXP_LIKE('hello\nworld', '.*hello\nworld.*')", BOOLEAN, true);
        assertFunction("REGEXP_LIKE('Hello', '^[a-z]+$')", BOOLEAN, false);
        assertFunction("REGEXP_LIKE('Hello', '^(?i)[a-z]+$')", BOOLEAN, true);
        assertFunction("REGEXP_LIKE('Hello', '^[a-zA-Z]+$')", BOOLEAN, true);
    }

    @Test
    public void testRegexCharLike()
    {
        assertFunction("REGEXP_LIKE('ala', CHAR 'ala  ')", BOOLEAN, false);
        assertFunction("REGEXP_LIKE('ala  ', CHAR 'ala  ')", BOOLEAN, true);
    }

    @Test
    public void testRegexpReplace()
    {
        assertFunction("REGEXP_REPLACE('fun stuff.', '[a-z]')", createVarcharType(10), " .");
        assertFunction("REGEXP_REPLACE('fun stuff.', '[a-z]', '*')", createVarcharType(65), "*** *****.");

        assertFunction(
                "REGEXP_REPLACE('call 555.123.4444 now', '(\\d{3})\\.(\\d{3}).(\\d{4})')",
                createVarcharType(21),
                "call  now");
        assertFunction(
                "REGEXP_REPLACE('call 555.123.4444 now', '(\\d{3})\\.(\\d{3}).(\\d{4})', '($1) $2-$3')",
                createVarcharType(2331),
                "call (555) 123-4444 now");

        assertFunction("REGEXP_REPLACE('xxx xxx xxx', 'x', 'x')", createVarcharType(71), "xxx xxx xxx");
        assertFunction("REGEXP_REPLACE('xxx xxx xxx', 'x', '\\x')", createVarcharType(143), "xxx xxx xxx");
        assertFunction("REGEXP_REPLACE('xxx', '', 'y')", createVarcharType(7), "yxyxyxy");
        assertInvalidFunction("REGEXP_REPLACE('xxx', 'x', '\\')", INVALID_FUNCTION_ARGUMENT);

        assertFunction("REGEXP_REPLACE('xxx xxx xxx', 'x', '$0')", createVarcharType(143), "xxx xxx xxx");
        assertFunction("REGEXP_REPLACE('xxx', '(x)', '$01')", createVarcharType(19), "xxx");
        assertFunction("REGEXP_REPLACE('xxx', 'x', '$05')", createVarcharType(19), "x5x5x5");
        assertFunction("REGEXP_REPLACE('123456789', '(1)(2)(3)(4)(5)(6)(7)(8)(9)', '$10')", createVarcharType(139), "10");
        assertFunction("REGEXP_REPLACE('1234567890', '(1)(2)(3)(4)(5)(6)(7)(8)(9)(0)', '$10')", createVarcharType(175), "0");
        assertFunction("REGEXP_REPLACE('1234567890', '(1)(2)(3)(4)(5)(6)(7)(8)(9)(0)', '$11')", createVarcharType(175), "11");
        assertFunction("REGEXP_REPLACE('1234567890', '(1)(2)(3)(4)(5)(6)(7)(8)(9)(0)', '$1a')", createVarcharType(175), "1a");
        assertInvalidFunction("REGEXP_REPLACE('xxx', 'x', '$1')", INVALID_FUNCTION_ARGUMENT);
        assertInvalidFunction("REGEXP_REPLACE('xxx', 'x', '$a')", INVALID_FUNCTION_ARGUMENT);
        assertInvalidFunction("REGEXP_REPLACE('xxx', 'x', '$')", INVALID_FUNCTION_ARGUMENT);

        assertFunction("REGEXP_REPLACE('wxyz', '(?<xyz>[xyz])', '${xyz}${xyz}')", createVarcharType(124), "wxxyyzz");
        assertFunction("REGEXP_REPLACE('wxyz', '(?<w>w)|(?<xyz>[xyz])', '[${w}](${xyz})')", createVarcharType(144), "[w]()[](x)[](y)[](z)");
        assertFunction("REGEXP_REPLACE('xyz', '(?<xyz>[xyz])+', '${xyz}')", createVarcharType(39), "z");
        assertFunction("REGEXP_REPLACE('xyz', '(?<xyz>[xyz]+)', '${xyz}')", createVarcharType(39), "xyz");
        assertInvalidFunction("REGEXP_REPLACE('xxx', '(?<name>x)', '${}')", INVALID_FUNCTION_ARGUMENT);
        assertInvalidFunction("REGEXP_REPLACE('xxx', '(?<name>x)', '${0}')", INVALID_FUNCTION_ARGUMENT);
        assertInvalidFunction("REGEXP_REPLACE('xxx', '(?<name>x)', '${nam}')", INVALID_FUNCTION_ARGUMENT);

        assertFunction("REGEXP_REPLACE(VARCHAR 'x', '.*', 'xxxxx')", createUnboundedVarcharType(), "xxxxxxxxxx");
    }

    @Test
    public void testRegexpExtract()
    {
        assertFunction("REGEXP_EXTRACT('Hello world bye', '\\b[a-z]([a-z]*)')", createVarcharType(15), "world");
        assertFunction("REGEXP_EXTRACT('Hello world bye', '\\b[a-z]([a-z]*)', 1)", createVarcharType(15), "orld");
        assertFunction("REGEXP_EXTRACT('rat cat\nbat dog', 'ra(.)|blah(.)(.)', 2)", createVarcharType(15), null);
        assertFunction("REGEXP_EXTRACT('12345', 'x')", createVarcharType(5), null);

        assertInvalidFunction("REGEXP_EXTRACT('Hello world bye', '\\b[a-z]([a-z]*)', -1)", INVALID_FUNCTION_ARGUMENT);
        assertInvalidFunction("REGEXP_EXTRACT('Hello world bye', '\\b[a-z]([a-z]*)', 2)", INVALID_FUNCTION_ARGUMENT);
    }

    @Test
    public void testRegexpExtractAll()
    {
        assertFunction("REGEXP_EXTRACT_ALL('rat cat\nbat dog', '.at')", new ArrayType(createVarcharType(15)), ImmutableList.of("rat", "cat", "bat"));
        assertFunction("REGEXP_EXTRACT_ALL('rat cat\nbat dog', '(.)at', 1)", new ArrayType(createVarcharType(15)), ImmutableList.of("r", "c", "b"));
        List<String> nullList = new ArrayList<>();
        nullList.add(null);
        assertFunction("REGEXP_EXTRACT_ALL('rat cat\nbat dog', 'ra(.)|blah(.)(.)', 2)", new ArrayType(createVarcharType(15)), nullList);
        assertInvalidFunction("REGEXP_EXTRACT_ALL('hello', '(.)', 2)", "Pattern has 1 groups. Cannot access group 2");

        assertFunction("REGEXP_EXTRACT_ALL('12345', '')", new ArrayType(createVarcharType(5)), ImmutableList.of("", "", "", "", "", ""));
        assertInvalidFunction("REGEXP_EXTRACT_ALL('12345', '(')", INVALID_FUNCTION_ARGUMENT);
    }

    @Test
    public void testRegexpSplit()
    {
        assertFunction("REGEXP_SPLIT('a.b:c;d', '[\\.:;]')", new ArrayType(createVarcharType(7)), ImmutableList.of("a", "b", "c", "d"));
        assertFunction("REGEXP_SPLIT('a.b:c;d', '\\.')", new ArrayType(createVarcharType(7)), ImmutableList.of("a", "b:c;d"));
        assertFunction("REGEXP_SPLIT('a.b:c;d', ':')", new ArrayType(createVarcharType(7)), ImmutableList.of("a.b", "c;d"));
        assertFunction("REGEXP_SPLIT('a,b,c', ',')", new ArrayType(createVarcharType(5)), ImmutableList.of("a", "b", "c"));
        assertFunction("REGEXP_SPLIT('a1b2c3d', '\\d')", new ArrayType(createVarcharType(7)), ImmutableList.of("a", "b", "c", "d"));
        assertFunction("REGEXP_SPLIT('a1b2346c3d', '\\d+')", new ArrayType(createVarcharType(10)), ImmutableList.of("a", "b", "c", "d"));
        assertFunction("REGEXP_SPLIT('abcd', 'x')", new ArrayType(createVarcharType(4)), ImmutableList.of("abcd"));
        assertFunction("REGEXP_SPLIT('abcd', '')", new ArrayType(createVarcharType(4)), ImmutableList.of("", "a", "b", "c", "d", ""));
        assertFunction("REGEXP_SPLIT('', 'x')", new ArrayType(createVarcharType(0)), ImmutableList.of(""));

        // test empty splits, leading & trailing empty splits, consecutive empty splits
        assertFunction("REGEXP_SPLIT('a,b,c,d', ',')", new ArrayType(createVarcharType(7)), ImmutableList.of("a", "b", "c", "d"));
        assertFunction("REGEXP_SPLIT(',,a,,,b,c,d,,', ',')", new ArrayType(createVarcharType(13)), ImmutableList.of("", "", "a", "", "", "b", "c", "d", "", ""));
        assertFunction("REGEXP_SPLIT(',,,', ',')", new ArrayType(createVarcharType(3)), ImmutableList.of("", "", "", ""));
    }
}


text:
<TITLE>Review for Witness (1985)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

Witness (1985)

reviewed by
Andrew Hicks

                                 WITNESS
                       A film review by Andrew Hicks
                Copyright 1997 Andrew Hicks / Fatboy Productions

(1985) *** (out of four)

        Aren't we all just a little bit fascinated with the Amish?
These are people who have rejected the American government
as well as every technological advancement of the last couple
centuries in favor of those oppressive suits, beards and brimmed
hats -- bonnets for the ladies. Those of us who are slave to
electricity and television, not to mention the utter extravagance
of running water, wonder what these inbred cults could see in
plowing and milking at 4:30 in the morning.

        These innate curiosities we all have about Amish people
are what elevates WITNESS from being just an average 80's action
flick. Harrison Ford, Mr. 80's Action Flick himself, plays a police
detective assigned to crack open the murder of a fellow officer. The
only witness to the murder is a little Amish boy (Lukas Haas) who
happened to be hiding in a bus station bathroom stall at the time of
the murder, most likely mesmerized by the flush technology.

        Ford drags Haas and his mother (Kelly "Top Gun"
McGillis, in her other movie appearance) to the police station,
making him root through mug shots and lineups. More
importantly, he exposes young Lukas to a world of sin and
corruption which McGillis and her bearded counterparts have been
trying to shelter him from. That's when Haas sees a picture of one
of the force's most respected officers (Danny Glover) and
recognizes him as the killer.

        Since, beneath its Amish exterior, this is a typical 80's
action movie, millions of dollars in drugs are involved and the
police corruption runs pretty much throughout the department.
So Ford has to find a place to hide himself and his Amish
witnesses. What better place than Pennsylvania Amish country?
That's when the tables are turned and Ford finds himself a fish out
of water, a fish in an oppressive suit and a bigass brimmed hat.

        WITNESS could have been a contrived comedy -- those
were very popular in the 80's -- but it instead tries to paint a
realistic portrait of Amish life. This ends up being a lot funnier
than a sitcom approach, because nothing is more laughable than
life itself. They bring out every Amish stereotype in the book,
even a barn-raising. In this age of political correctness, the Amish
are one of the last constituent groups that are still safe to make fun
of, probably because they won't ever see or hear about what's being
said about them, nor do they care. In their eyes, Billy Graham is a
heathen for owning an electric hair dryer.

        The middle half of the movie is the actionless assimilation
of Ford into the Amish community, which is always interesting if
not amusing. Crusty old Eli doesn't like Ford too much, especially
when he finds him dancing to rock music with his daughter
(McGillis). Amish Kelly doesn't compromise herself with Ford
beyond the realm of hungry French kisses, even if she does appear
topless in a shower scene. That's where I really wouldn't have
minded the Puritan approach; McGillis looks just like my high
school Bible teacher. Seeing her make out with Tom Cruise was
bad enough.

--

Visit the Movie Critic at LARGE homepage at
http://www.missouri.edu/~c667778/movies.html

Serving America For Over 1/33rd of a Century!

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews


text:
<?php

// autoload.php generated by Composer

require_once __DIR__ . '/composer' . '/autoload_real.php';

return ComposerAutoloaderInit09cef41c3785aa0ae222f7302af01004::getLoader();


text:
<!DOCTYPE html>

    <meta charset="utf-8" />
    <title>statsmodels.nonparametric.kernel_regression.KernelReg.aic_hurvich — statsmodels v0.10.0 documentation</title>
    <link rel="stylesheet" href="../_static/nature.css" type="text/css" />
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    <link rel="stylesheet" type="text/css" href="../_static/graphviz.css" />

    <link rel="shortcut icon" href="../_static/statsmodels_hybi_favico.ico"/>
    <link rel="author" title="About these documents" href="../about.html" />
    <link rel="index" title="Index" href="../genindex.html" />
    <link rel="search" title="Search" href="../search.html" />
    <link rel="next" title="statsmodels.nonparametric.kernel_regression.KernelReg.cv_loo" href="statsmodels.nonparametric.kernel_regression.KernelReg.cv_loo.html" />
    <link rel="prev" title="statsmodels.nonparametric.kernel_regression.KernelReg" href="statsmodels.nonparametric.kernel_regression.KernelReg.html" />
<link rel="stylesheet" href="../_static/examples.css" type="text/css" />
<link rel="stylesheet" href="../_static/facebox.css" type="text/css" />

Navigation

          index

          modules |

          next |

          previous |

Install
  |

Support
  |

Bugs
  |

Develop
  |

Examples
  |

FAQ
  |

Nonparametric Methods nonparametric |

statsmodels.nonparametric.kernel_regression.KernelReg |

statsmodels.nonparametric.kernel_regression.KernelReg.aic_hurvich¶

method

KernelReg.aic_hurvich(bw, func=None)[source]¶

Computes the AIC Hurvich criteria for the estimation of the bandwidth.

Parameters

bwstr or array_like

See the bw parameter of KernelReg for details.

Returns

aicndarray

The AIC Hurvich criteria, one element for each variable.

funcNone

Unused here, needed in signature because it's used in cv_loo.

References

See ch.2 in [1] and p.35 in [2].

Previous topic

statsmodels.nonparametric.kernel_regression.KernelReg

Next topic

statsmodels.nonparametric.kernel_regression.KernelReg.cv_loo

This Page

Show Source

Quick search

    <form class="search" action="../search.html" method="get">
      <input type="text" name="q" aria-labelledby="searchlabel" />
      <input type="submit" value="Go" />
    </form>

        © Copyright 2009-2018, Josef Perktold, Skipper Seabold, Jonathan Taylor, statsmodels-developers.
      Created using Sphinx 2.1.2.


text:
/**
 * CheckBoxTreeView widget. Extrends TreeView widget to support relevant events and methods od checkbox tree.
 * This widget represents the root cotainer for CheckBoxTreeNode objects that build the actual tree structure.
 * Therefore this widget will not usually have any visual representation. Its also responsible for handling node events.
 * @class CheckBoxTreeView
 * @constructor
 * @extends TreeView
 * @param {Object} config User configuration object.
 */
	Y.CheckBoxTreeView = Y.Base.create(CHECKBOXTREEVIEW, Y.TreeView, [], {

		initializer : function(config) {
			/**
			 * Fires when node checkbox state is changed
			 * @event check
			 * @param {TreeNode} treenode tree node that is checked
			 */
			this.publish("check", {
				defaultFn: this._checkDefaultFn
			});
		},

		/**
		 * Default event handler for "check" event
		 * @method _nodeClickDefaultFn
		 * @protected
		 */
		_checkDefaultFn: function(e) {
			e.treenode.toggleCheckedState();
		},

		bindUI: function() {
			var boundingBox = this.get(BOUNDING_BOX);
			Y.CheckBoxTreeView.superclass.bindUI.apply(this, arguments);

			boundingBox.on("click", function(e) {
				var twidget = Y.Widget.getByNode(e.target),
					check = false;
				if (twidget instanceof Y.CheckBoxTreeNode) {
					Y.Array.each(e.target.get("className").split(" "), function (className) {
						switch (className) {
							case classNames.checkbox:
								check = true;
								break;
							case classNames.labelContent:
								if (this.get("checkOnLabelClick")) {
									check = true;
								}
								break;
						}
					}, this);

					if (check) {
						this.fire("check", {treenode: twidget});
					}
				}
			}, this);

			boundingBox.on("keypress", function(e) {
				var target = e.target,
					twidget = Y.Widget.getByNode(target),
					keycode = e.keyCode;

				if (!twidget instanceof Y.CheckBoxTreeNode) {
					return;
				}

				if (keycode == 32) {
					this.fire("check", {treenode: twidget});
					e.preventDefault();
				}
			}, this);
		},

		/**
		 * Returns the list of nodes that are roots of checked subtrees
		 * @method getChecked
		 * @return {Array} array of tree nodes
		 */
		getChecked : function() {
			var checkedChildren = Array(),
				halfcheckedChildren = Array(),
				child,
				analyzeChild;

				this.each(function (child) {
					if (child.get("checked") == checkStates.checked) {
						checkedChildren.push(child);
					} else if (child.get("checked") == checkStates.halfchecked) {
						halfcheckedChildren.push(child);
					}
				});

				analyzeChild = function (child) {
					if (child.get("checked") == checkStates.checked) {
						checkedChildren.push(child);
					} else if (child.get("checked") == checkStates.halfchecked) {
						halfcheckedChildren.push(child);
					}
				};

				while (halfcheckedChildren.length > 0) {
					child = halfcheckedChildren.pop();
					child.each(analyzeChild);
				}
				return checkedChildren;
		},

		/**
		 * Returns list of pathes (breadcrumbs) of nodes that are roots of checked subtrees
		 * @method getCheckedPaths
		 * @param cfg {Object} An object literal with the following properties:
		 *

		 *
labelAttr

		 *
Attribute name to use for node representation. Can be any attribute of TreeNode

		 *
reverse

		 *
Return breadcrumbs from the node to root instead of root to the node

		 *

		 * @return {Array} array of node label arrays
		 */
		getCheckedPaths : function(cfg) {
			var nodes = this.getChecked(),
			nodeArray = Array();

			if (!cfg) {
				cfg = {};
			}
			if (!cfg.labelAttr) {
				cfg.labelAttr = "label";
			}

			Y.Array.each(nodes, function(node) {
				nodeArray.push(node.path(cfg));
			});
			return nodeArray;
		}

	}, {
		NAME : CHECKBOXTREEVIEW,
		ATTRS : {
			/**
			 * @attribute defaultChildType
			 * @type String
			 * @readOnly
			 * @description default child type definition
			 */
			defaultChildType : {
				value: "CheckBoxTreeNode",
				readOnly: true
			},
			/**
			 * @attribute checkOnLabelClick
			 * @type Boolean
			 * @description Whether to change node checked state on label clicks with addition to checkbox control clicks
			 */
			checkOnLabelClick : {
				value: true,
				validator: Y.Lang.isBoolean
			}
		}
	});

/**
 * CheckBoxTreeNode widget. Provides a tree style node widget with checkbox
 * It extends Y.TreeNode, please refer to it's documentation for more info.
 * @class CheckBoxTreeNode
 * @constructor
 * @extends TreeNode
 * @param {Object} config User configuration object.
 */
	Y.CheckBoxTreeNode = Y.Base.create(CHECKBOXTREENODE, Y.TreeNode, [], {

		initializer : function() {
			this.publish("childCheckedSateChange", {
				defaultFn: this._childCheckedSateChangeDefaultFn,
				bubbles: false
			});
		},

		/**
		* Default handler for childCheckedSateChange. Updates this parent state
		* to match current children states.
		* @method _childCheckedSateChangeDefaultFn
		* @protected
		*/
		_childCheckedSateChangeDefaultFn : function(e) {
			var checkedChildren = 0,
				halfCheckedChildren = 0,
				cstate;

			this.each(function(child) {
				cstate = child.get("checked");
				if (cstate == checkStates.checked) {
					checkedChildren++;
				}
				if (cstate == checkStates.halfchecked) {
					halfCheckedChildren++;
				}
			});

			if (checkedChildren == this.size()) {
				this.set("checked", checkStates.checked);
			} else if (checkedChildren > 0 || halfCheckedChildren > 0) {
				this.set("checked", checkStates.halfchecked);
			} else {
				this.set("checked", checkStates.unchecked);
			}

			if (!this.isRoot()) {
				this.get("parent").fire("childCheckedSateChange");
			}
		},

		bindUI : function() {
			Y.CheckBoxTreeNode.superclass.bindUI.apply(this, arguments);
			this.on("checkedChange", this._onCheckedChange);
		},

		/**
		* Event handler that updates UI according to checked attribute change
		* @method _onCheckedChange
		* @protected
		*/
		_onCheckedChange: function(e) {
			e.stopPropagation();
			this._updateCheckedStateUI(e.prevVal, e.newVal);
		},

		/**
		* Synchronize CSS classes to conform to checked state
		* @method _updateCheckedStateUI
		* @protected
		*/
		_updateCheckedStateUI : function(oldState, newState) {
			var checkBox = this._getCheckBoxNode();
			checkBox.removeClass(checkStatesClasses[oldState]);
			checkBox.addClass(checkStatesClasses[newState]);
		},

		/**
		* Returns checkbox node
		* @method _getCheckBoxNode
		* @protected
		*/
		_getCheckBoxNode : function() {
			return this.get(BOUNDING_BOX).one("." + classNames.checkbox);
		},

		CHECKBOX_TEMPLATE : "",

		renderUI : function() {
			var parentNode,
			labelContentNode,
			checkboxNode;

			Y.CheckBoxTreeNode.superclass.renderUI.apply(this, arguments);

			checkboxNode = Y.Node.create(Y.substitute(this.CHECKBOX_TEMPLATE, {checkboxClassName: classNames.checkbox}));
			labelContentNode = this._getLabelContentNode();
			parentNode = labelContentNode.get("parentNode");
			labelContentNode.remove();
			checkboxNode.append(labelContentNode);
			parentNode.append(checkboxNode);

			// update state
			this._getCheckBoxNode().addClass(checkStatesClasses[this.get("checked")]);

			// reuse CSS
			this.get(CONTENT_BOX).addClass(classNames.content);
		},

		syncUI : function() {
			Y.CheckBoxTreeNode.superclass.syncUI.apply(this, arguments);
			this._syncChildren();
		},

		/**
		* Toggles checked / unchecked state of the node
		* @method toggleCheckedState
		*/
		toggleCheckedState : function() {
			if (this.get("checked") == checkStates.checked) {
				this._uncheck();
			} else {
				this._check();
			}
			this.get("parent").fire("childCheckedSateChange");
		},

		/**
		 * Sets this node as checked and propagates to children
		 * @method _check
		 * @protected
		 */
		_check : function() {
			this.set("checked", checkStates.checked);
			this.each(function(child) {
				child._check();
			});
		},

		/**
		 * Set this node as unchecked and propagates to children
		 * @method _uncheck
		 * @protected
		 */
		_uncheck : function() {
			this.set("checked", checkStates.unchecked);
			this.each(function(child) {
				child._uncheck();
			});
		},

		/**
		 * Synchronizes children states to match the state of the current node
		 * @method _uncheck
		 * @protected
		 */
		_syncChildren : function() {
			if (this.get("checked") == checkStates.unchecked) {
				this._uncheck();
			} else if (this.get("checked") == checkStates.checked) {
				this._check();
			} else {
				this.each(function (child) {
					child._syncChildren();
				});
			}
		}

	}, {
		NAME : CHECKBOXTREENODE,
		ATTRS : {
			/**
			* @attribute defaultChildType
			* @type String
			* @readOnly
			* @description default child type definition
			*/
			defaultChildType : {
				value: "CheckBoxTreeNode",
				readOnly: true
			},
			/**
			* @attribute checked
			* @type {String|Number}
			* @description Signifies current "checked" state. Accepts either unchecked, halfchecked, checked.
			* or correspondingly 10, 20, 30. Getter returns only numeric value.
			*/
			checked : {
				value : 10,
				setter : function(val) {
					var returnVal = Y.Attribute.INVALID_VALUE;
					if (checkStates[val] !== null) {
						returnVal = checkStates[val];
					} else if ([10, 20, 30].indexOf(val) >= 0) {
						returnVal = val;
					}
					return returnVal;
				}
			}
		}
	});


text:
#import <CryptKit/CryptKit.h>
#import <CryptKit/CipherFileTypes.h>

@interface NSCipherFile : NSObject
{
	void	*_priv;
}

/*
 * Alloc and return an autoreleased NSCipherFile object associated with
 * the specified data.
 */
+ newFromCipherText : (NSData *)cipherText
	encrType : (cipherFileEncrType)encrType
	sendPubKeyData : (NSData *)sendPubKeyData
	otherKeyData : (NSData *)otherKeyData
	sigData : (NSData *)sigData	// optional; nil means no signature
	userData : (unsigned)userData;	// for caller's convenience

/*
 * Obtain the contents of a feeCipherFile as NSData.
 */
- (NSData *)dataRepresentation;

/*
 * Alloc and return an autoreleased NSCipherFile object given a data
 * representation.
 */
+ newFromDataRepresentation : (NSData *)dataRep;

/*
 * Given an NSCipherFile object, obtain its constituent parts.
 */
- (cipherFileEncrType)encryptionType;
- (NSData *)cipherText;
- (NSData *)sendPubKeyData;
- (NSData *)otherKeyData;
- (NSData *)sigData;
- (unsigned)userData;

/*
 * High-level cipherFile support.
 */

/*
 * Obtain the data representation of a NSCipherFile given the specified
 * plainText and cipherFileEncrType.
 * Receiver's public key is required for all encrTypes; sender's private
 * key is required for signature generation and also for encrType
 * CFE_PublicDES and CFE_FEED.
 */
+(feeReturn)createCipherFileForPrivKey : (NSFEEPublicKey *)sendPrivKey
	recvPubKey : (NSFEEPublicKey *)recvPubKey
	encrType : (cipherFileEncrType)encrType
	plainText : (NSData *)plainText
	genSig : (BOOL)genSig
	doEnc64 : (BOOL)doEnc64			// YES ==> perform enc64
	userData : (unsigned)userData		// for caller's convenience
	cipherFileData : (NSData **)cipherFileData;	// RETURNED

/*
 * Parse and decrypt a data representation of an NSCipherFile object.
 *
 * recvPrivKey is required in all cases. If sendPubKey is present,
 * sendPubKey - rather than the embedded sender's public key - will be
 * used for signature validation.
 */
+ (feeReturn)parseCipherFileData : (NSFEEPublicKey *)recvPrivKey
	sendPubKey : (NSFEEPublicKey *)sendPubKey
	cipherFileData : (NSData *)cipherFileData
	doDec64 : (BOOL)doDec64
	encrType : (cipherFileEncrType *)encrType	// RETURNED
	plainText : (NSData **)plainText		// RETURNED
	sigStatus : (feeSigStatus *)sigStatus		// RETURNED
	sigSigner : (NSString **)sigSigner		// RETURNED
	userData : (unsigned *)userData;		// RETURNED

/*
 * Parse and decrypt an NSCipherFile object obtained via
 * +newFromDataRepresentation.
 *
 * recvPrivKey is required in all cases. If sendPubKey is present,
 * sendPubKey - rather than the embedded sender's public key - will be
 * used for signature validation.
 */
- (feeReturn)decryptCipherFileData : (NSFEEPublicKey *)recvPrivKey
	sendPubKey : (NSFEEPublicKey *)sendPubKey
	plainText : (NSData **)plainText		// RETURNED
	sigStatus : (feeSigStatus *)sigStatus		// RETURNED
	sigSigner : (NSString **)sigSigner;		// RETURNED

@end


text:
/**
 * Multipart support.
 */
@NonNullApi
@NonNullFields
package org.springframework.http.codec.multipart;

import org.springframework.lang.NonNullApi;
import org.springframework.lang.NonNullFields;


text:
//
//  Generated by the J2ObjC translator.  DO NOT EDIT!
//  source: ./core/src/java/org/apache/lucene/util/BitSetIterator.java
//

#include "J2ObjC_header.h"

#pragma push_macro("INCLUDE_ALL_OrgApacheLuceneUtilBitSetIterator")
#ifdef RESTRICT_OrgApacheLuceneUtilBitSetIterator
#define INCLUDE_ALL_OrgApacheLuceneUtilBitSetIterator 0
#else
#define INCLUDE_ALL_OrgApacheLuceneUtilBitSetIterator 1
#endif
#undef RESTRICT_OrgApacheLuceneUtilBitSetIterator

#if __has_feature(nullability)
#pragma clang diagnostic push
#pragma GCC diagnostic ignored "-Wnullability"
#pragma GCC diagnostic ignored "-Wnullability-completeness"
#endif

#if !defined (OrgApacheLuceneUtilBitSetIterator_) && (INCLUDE_ALL_OrgApacheLuceneUtilBitSetIterator || defined(INCLUDE_OrgApacheLuceneUtilBitSetIterator))
#define OrgApacheLuceneUtilBitSetIterator_

#define RESTRICT_OrgApacheLuceneSearchDocIdSetIterator 1
#define INCLUDE_OrgApacheLuceneSearchDocIdSetIterator 1
#include "org/apache/lucene/search/DocIdSetIterator.h"

@class OrgApacheLuceneUtilBitSet;
@class OrgApacheLuceneUtilFixedBitSet;
@class OrgApacheLuceneUtilSparseFixedBitSet;

/*!
 @brief A DocIdSetIterator which iterates over set bits in a
  bit set.
 */
@interface OrgApacheLuceneUtilBitSetIterator : OrgApacheLuceneSearchDocIdSetIterator

#pragma mark Public

/*!
 @brief Sole constructor.
 */
- (instancetype __nonnull)initWithOrgApacheLuceneUtilBitSet:(OrgApacheLuceneUtilBitSet *)bits
                                                   withLong:(jlong)cost;

- (jint)advanceWithInt:(jint)target;

- (jlong)cost;

- (jint)docID;

/*!
 @brief If the provided iterator wraps a FixedBitSet, returns it, otherwise returns null.
 */
+ (OrgApacheLuceneUtilFixedBitSet *)getFixedBitSetOrNullWithOrgApacheLuceneSearchDocIdSetIterator:(OrgApacheLuceneSearchDocIdSetIterator *)iterator;

/*!
 @brief If the provided iterator wraps a SparseFixedBitSet, returns it, otherwise returns null.
 */
+ (OrgApacheLuceneUtilSparseFixedBitSet *)getSparseFixedBitSetOrNullWithOrgApacheLuceneSearchDocIdSetIterator:(OrgApacheLuceneSearchDocIdSetIterator *)iterator;

- (jint)nextDoc;

// Disallowed inherited constructors, do not use.

- (instancetype __nonnull)init NS_UNAVAILABLE;

@end

J2OBJC_EMPTY_STATIC_INIT(OrgApacheLuceneUtilBitSetIterator)

FOUNDATION_EXPORT OrgApacheLuceneUtilFixedBitSet *OrgApacheLuceneUtilBitSetIterator_getFixedBitSetOrNullWithOrgApacheLuceneSearchDocIdSetIterator_(OrgApacheLuceneSearchDocIdSetIterator *iterator);

FOUNDATION_EXPORT OrgApacheLuceneUtilSparseFixedBitSet *OrgApacheLuceneUtilBitSetIterator_getSparseFixedBitSetOrNullWithOrgApacheLuceneSearchDocIdSetIterator_(OrgApacheLuceneSearchDocIdSetIterator *iterator);

FOUNDATION_EXPORT void OrgApacheLuceneUtilBitSetIterator_initWithOrgApacheLuceneUtilBitSet_withLong_(OrgApacheLuceneUtilBitSetIterator *self, OrgApacheLuceneUtilBitSet *bits, jlong cost);

FOUNDATION_EXPORT OrgApacheLuceneUtilBitSetIterator *new_OrgApacheLuceneUtilBitSetIterator_initWithOrgApacheLuceneUtilBitSet_withLong_(OrgApacheLuceneUtilBitSet *bits, jlong cost) NS_RETURNS_RETAINED;

FOUNDATION_EXPORT OrgApacheLuceneUtilBitSetIterator *create_OrgApacheLuceneUtilBitSetIterator_initWithOrgApacheLuceneUtilBitSet_withLong_(OrgApacheLuceneUtilBitSet *bits, jlong cost);

J2OBJC_TYPE_LITERAL_HEADER(OrgApacheLuceneUtilBitSetIterator)

#endif

#if __has_feature(nullability)
#pragma clang diagnostic pop
#endif
#pragma pop_macro("INCLUDE_ALL_OrgApacheLuceneUtilBitSetIterator")


text:
package org.plummtw.jinrou.enum

import org.plummtw.jinrou.data._

object SubroleEnum extends Enumeration {
  type SubroleEnum = Value

  val NONE          = Value("0")
  val DECIDER      = Value("D")
  val AUTHORITY    = Value("A")
  val MEMORYLOSS4  = Value("4")
  val MEMORYLOSS6  = Value("6")
  val MEMORYLOSS8  = Value("8")
  val FAKEAUGURER  = Value("F")
  val SUDDENDEATH  = Value("I")
  val AVENGER       = Value("V")
  val WOLFBELIEVER = Value("W")
  val FOXBELIEVER  = Value("B")
  val ALPHAWOLF    = Value("X")
  val WISEWOLF     = Value("Y")
  val WOLFSTAMP    = Value("Z")
  val SUBPONTIFF   = Value("P")
  val NORELIGION    = Value("N")
  val HASHIHIME     = Value("H")

  def SUBROLE_MAP   =scala.collection.immutable.TreeMap(
     NONE        -> SubroleNone,
     DECIDER     -> SubroleDecider,
     AUTHORITY   -> SubroleAuthority,
     MEMORYLOSS4 -> SubroleMemoryLoss4,
     MEMORYLOSS6 -> SubroleMemoryLoss6,
     MEMORYLOSS8 -> SubroleMemoryLoss8,
     FAKEAUGURER -> SubroleFakeAugurer,
     SUDDENDEATH -> SubroleSuddenDeath,
     AVENGER     -> SubroleAvenger,
     WOLFBELIEVER -> SubroleWolfBeliever,
     FOXBELIEVER -> SubroleFoxBeliever,
     ALPHAWOLF   -> SubroleAlphaWolf,
     WISEWOLF    -> SubroleWiseWolf,
     WOLFSTAMP   -> SubroleWolfStamp,
     SUBPONTIFF  -> SubroleSubpontiff,
     NORELIGION  -> SubroleNoreligion,
     HASHIHIME   -> SubroleHashihime
  )

  def get_subrole(subrole : SubroleEnum.Value) : SubroleData= {
    val result = SUBROLE_MAP.get(subrole)
    //if (result.isEmpty)
    //  println(subrole.toString + "is null")
    return result.getOrElse(SubroleNone)
  }

  def get_subrole(role_string : String) : SubroleData = {
    return get_subrole(valueOf(role_string).getOrElse(NONE))
  }
}


text:
<!DOCTYPE html>

  <meta charset="utf-8" />
  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
  <meta name="HandheldFriendly" content="true" />
  <link rel="shortcut icon" href="https://www.epa.gov/sites/all/themes/epa/favicon.ico" type="image/vnd.microsoft.icon" />
  <meta name="MobileOptimized" content="width" />
  <meta http-equiv="cleartype" content="on" />
  <meta http-equiv="ImageToolbar" content="false" />
  <meta name="viewport" content="width=device-width" />
  <meta name="version" content="20161218" />

  <meta name="DC.description" content="" />
  <meta name="DC.title" content="" />
  <title>
  A Continuation of Remediation of Brine Spills with Hay|

  Research Project Database | Grantee Research Project | ORD | US EPA</title>

  <meta name="keywords" content="" />
  <link rel="shortlink" href="" />
  <link rel="canonical" href="" />
  <meta name="DC.creator" content="" />
  <meta name="DC.language" content="en" />
  <meta name="DC.Subject.epachannel" content="" />
  <meta name="DC.type" content="" />
  <meta name="DC.date.created" content="" />
  <meta name="DC.date.modified" content="2003-05-14" />

  <link type="text/css" rel="stylesheet" href="https://www.epa.gov/misc/ui/jquery.ui.autocomplete.css" media="all" />
  <link type="text/css" rel="stylesheet" href="https://www.epa.gov/sites/all/themes/epa/css/lib/jquery.ui.theme.css" media="all" />
  <link type="text/css" rel="stylesheet" href="https://www.epa.gov/sites/all/libraries/template2/s.css" media="all" />

	<link rel="alternate" type="application/atom+xml" title="EPA.gov All Press Releases" href="https://www.epa.gov/newsreleases/search/rss" />
	<link rel="alternate" type="application/atom+xml" title="EPA.gov Headquarters Press Releases" href="https://www.epa.gov/newsreleases/search/rss/field_press_office/headquarters" />
	<link rel="alternate" type="application/atom+xml" title="Greenversations, EPA's Blog" href="https://blog.epa.gov/blog/feed/" />

Jump to main content

  <hgroup class="site-name-and-slogan">

US EPA

United States Environmental Protection Agency

  </hgroup>
  <form class="epa-search" method="get" action="https://search.epa.gov/epasearch/epasearch">
    Search
    <input class="form-text" placeholder="Search EPA.gov" name="querytext" id="search-box" value=""/>
    <button class="epa-search-button" id="search-button" type="submit" title="Search">Search</button>
    <input type="hidden" name="fld" value="" />
    <input type="hidden" name="areaname" value="" />
    <input type="hidden" name="areacontacts" value="" />
    <input type="hidden" name="areasearchurl" value="" />
    <input type="hidden" name="typeofsearch" value="epa" />
    <input type="hidden" name="result_template" value="2col.ftl" />
    <input type="hidden" name="filter" value="sample4filt.hts" />
  </form>

Contact Us

Project Research Results

Final Report

                        3 publications for this subproject

                          Main Center: R827015

                        120 publications for this center

                          16 journal articles for this center

Related Information

Research Grants

P3: Student Design Competition

Research Fellowships

Small Business Innovation Research (SBIR)

Grantee Research Project Results Search

      A Continuation of Remediation of Brine Spills with Hay

    EPA Grant Number: R827015C025

        Subproject: this is subproject number 025 , established and managed by the Center Director under

          grant R827015

        (EPA does not fund or establish subprojects; EPA awards and manages the overall grant for this center).

      Center:

        IPEC University of Tulsa (TU)

      Center Director:

         Sublette, Kerry L.

    Title: A Continuation of Remediation of Brine Spills with Hay

    Investigators:
     Ford, Laura P.
        ,  Sublette, Kerry L.

    Institution:

      University of Tulsa

    	EPA Project Officer:

           Lasat, Mitch

      Project Period:

          (Extended to August 31, 2004)

      RFA:
      Integrated Petroleum Environmental Consortium (IPEC) (1999)

        		RFA Text |
          Recipients Lists

      Research Category:

          Hazardous Waste/Remediation
          ,
          Targeted Research

Objective:

This project is a continuation of the IPEC project Remediation of
Brine Spills with Hay.  In the first year of this project, we set up a
field demonstration to treat two produced fluids spill sites and a control
site with four different soil amendments to determine the effectiveness of
hay as a soil amendment for brine spills.  Our four soil treatments are
tilling, tilling with hay, tilling with fertilizer, and tilling with hay
and fertilizer.  Eight microcosms were built to treat contaminated soil
with the same soil amendments and provide controlled watering and aeration.
 The field sites and microcosms have been sampled regularly to track
changes in concentrations of brine components, soil properties, and
microbial populations to determine the mechanism(s) by which remediation
occurs.

Approach:

We have proposed three mechanisms by which organic matter (hay) may
aid the removal of salt.  (1) The hay may provide pores for water to enter
the soil and leach salt components away.  (2) Compounds formed during the
decay of the hay can exchange cations with the clay, releasing sodium from
the clay.  (3) Products formed during the decay of hay can bind the clay
particles into water-stable aggregates.  All mechanisms improve the
permeability of the soil, allowing water to flush salt from the soil.  The
first mechanism should dominate early in a remediation project.  The second
and third mechanisms should become more important as the hay decays.
Microbial action is important to all three mechanisms:  biodegradation of
the hay will decrease the rate of the first and increase the rates of the
other two proposed mechanisms.

First year results indicate that the first mechanism is probably
active:  permeability appeared to increase in the sites and microcosms with
hay.  The second and third mechanisms did not appear to be active.
Microorganisms in sites and microcosms with hay were different from those
without hay.  Salt components decreased more in microcosms with hay than
those without.  Over the first year, salt components decreased most in the
sites with tilling and fertilizer, interestingly.

This project continues the field demonstration component of the first
year, since the sites received little rain to wash the salt away in the
first year.  We will sample the field sites monthly during wet, warm months
and quarterly otherwise.  We will continue to analyze the samples for
cation and anion concentrations, nutrient concentrations, cation exchange
capacity, hydraulic conductivity, wet aggregate stability, and microbial
population and diversity.  A dual ring infiltrometer will be used to
measure hydraulic conductivity/permeability in situ instead of the
unreliable, ex situ technique used in the first year.  We will also perform
denaturing gradient gel electrophoresis at the end of the second year to
identify important species in the field sites, for comparison with results
from the microcosms.  To better see where the microorganisims are (soil
versus hay), we will do plate counting of microorganisms cultured from the
soil and from the hay.  If rainfall is low in the hot summer months, we
will water the sites to ensure that changes are seen over the second year
of the project.

Publications and Presentations:

        Publications have been submitted on this subproject: View all 3 publications for this subproject

              | View all 120 publications for this center

Supplemental Keywords:

      Scientific Discipline, Geographic Area, Waste, Water, Hydrology, Contaminated Sediments, Remediation, Chemistry, State, Civil/Environmental Engineering, Engineering, Environmental Engineering, biodegradation, contaminated sediment, brine impacted soil, soils, contaminated soil, subsurface drainage system, hay, desalination, Oklahoma (OK)

Progress and Final Reports:

                Final Report

Main Center Abstract and Reports:

        R827015

          IPEC University of Tulsa (TU)

 Subprojects under this Center: (EPA does not fund or establish subprojects; EPA awards and manages the overall grant for this center).

            R827015C001 Evaluation of Road Base Material Derived from Tank Bottom Sludges

            R827015C002 Passive Sampling Devices (PSDs) for Bioavailability Screening of Soils Containing Petrochemicals

            R827015C003 Demonstration of a Subsurface Drainage System for the Remediation of Brine-Impacted Soil

            R827015C004 Anaerobic Intrinsic Bioremediation of Whole Gasoline

            R827015C005 Microflora Involved in Phytoremediation of Polyaromatic Hydrocarbons

            R827015C006 Microbial Treatment of Naturally Occurring Radioactive Material (NORM)

            R827015C007 Using Plants to Remediate Petroleum-Contaminated Soil

            R827015C008 The Use of Nitrate for the Control of Sulfide Formation in Oklahoma Oil Fields

            R827015C009 Surfactant-Enhanced Treatment of Oil-Contaminated Soils and Oil-Based Drill Cuttings

            R827015C010 Novel Materials for Facile Separation of Petroleum Products from Aqueous Mixtures Via Magnetic Filtration

            R827015C011 Development of Relevant Ecological Screening Criteria (RESC) for Petroleum Hydrocarbon-Contaminated Exploration and Production Sites

            R827015C012 Humate-Induced Remediation of Petroleum Contaminated Surface Soils

            R827015C013 New Process for Plugging Abandoned Wells

            R827015C014 Enhancement of Microbial Sulfate Reduction for the Remediation of Hydrocarbon Contaminated Aquifers - A Laboratory and Field Scale Demonstration

            R827015C015 Locating Oil-Water Interfaces in Process Vessels

            R827015C016 Remediation of Brine Spills with Hay

            R827015C017 Continuation of an Investigation into the Anaerobic Intrinsic Bioremediation of Whole Gasoline

            R827015C018 Using Plants to Remediate Petroleum-Contaminated Soil

            R827015C019 Biodegradation of Petroleum Hydrocarbons in Salt-Impacted Soil by Native Halophiles or Halotolerants and Strategies for Enhanced Degradation

            R827015C020 Anaerobic Intrinsic Bioremediation of MTBE

            R827015C021 Evaluation of Commercial, Microbial-Based Products to Treat Paraffin Deposition in Tank Bottoms and Oil Production Equipment

            R827015C022 A Continuation: Humate-Induced Remediation of Petroleum Contaminated Surface Soils

            R827015C023 Data for Design of Vapor Recovery Units for Crude Oil Stock Tank Emissions

            R827015C024 Development of an Environmentally Friendly and Economical Process for Plugging Abandoned Wells

            R827015C025 A Continuation of Remediation of Brine Spills with Hay

            R827015C026 Identifying the Signature of the Natural Attenuation of MTBE in Goundwater Using Molecular Methods and "Bug Traps"

            R827015C027 Identifying the Signature of Natural Attenuation in the Microbial
  Ecology of Hydrocarbon Contaminated Groundwater Using Molecular Methods and
  "Bug Traps"

            R827015C028 Using Plants to Remediate Petroleum-Contaminated Soil: Project Continuation

            R827015C030 Effective Stormwater and Sediment Control During Pipeline Construction Using a New Filter Fence Concept

            R827015C031 Evaluation of Sub-micellar Synthetic Surfactants versus Biosurfactants for Enhanced LNAPL Recovery

            R827015C032 Utilization of the Carbon and Hydrogen Isotopic Composition of Individual Compounds in Refined Hydrocarbon Products To Monitor Their Fate in the Environment

            R830633 Integrated Petroleum Environmental Consortium (IPEC)

            R830633C001 Development of an Environmentally Friendly and Economical Process for Plugging Abandoned Wells (Phase II)

            R830633C002 A Continuation of Remediation of Brine Spills with Hay

            R830633C003 Effective Stormwater and Sediment Control During Pipeline Construction Using a New Filter Fence Concept

            R830633C004 Evaluation of Sub-micellar Synthetic Surfactants versus Biosurfactants for Enhanced LNAPL Recovery

            R830633C005 Utilization of the Carbon and Hydrogen Isotopic Composition of Individual Compounds in Refined Hydrocarbon Products To Monitor Their Fate in the Environment

            R830633C006 Evaluation of Commercial, Microbial-Based Products to Treat Paraffin Deposition in Tank Bottoms and Oil Production Equipment

            R830633C007 Identifying the Signature of the Natural Attenuation in the Microbial Ecology of Hydrocarbon Contaminated Groundwater Using Molecular Methods and “Bug Traps”

            R830633C008 Using Plants to Remediate Petroleum-Contaminated Soil: Project Continuation

            R830633C009 Use of Earthworms to Accelerate the Restoration of Oil and Brine Impacted Sites

Top of Page

 The perspectives, information and conclusions conveyed in research project abstracts, progress reports, final reports, journal abstracts and journal publications convey the viewpoints of the principal investigator and may not represent the views and policies of ORD and EPA.  Conclusions drawn by the principal investigators have not been reviewed by the Agency.

Main menu

Environmental Topics

Laws & Regulations

About EPA

Discover.

Accessibility

EPA Administrator

Budget & Performance

Contracting

Grants

No FEAR Act Data

Privacy and Security

Connect.

Data.gov

Inspector General

Jobs

Newsroom

Open Government

Regulations.gov

Subscribe

USA.gov

White House

Ask.

Contact Us

Hotlines

FOIA Requests

Frequent Questions

Follow.

Facebook

Twitter

YouTube

Flickr

Instagram

Last updated on Wednesday, May 14, 2003


text:
require 'spec_helper'

set :os, :family => 'aix'

describe port(80) do
  it { should be_listening }
end

describe port(80) do
  it { should be_listening.with('tcp') }
end

describe port(80) do
  it { should be_listening.on('127.0.0.1') }
end

describe port(53) do
  it { should be_listening.with('udp') }
end


text:
import {isArray} from '../../util/is-array.js';
import {isFalsy} from '../../util/is-falsy.js';
import {every} from '../../util/every.js';

/**
 * Check that the tested object contains only falsy values.
 * The tested object may be an array or any iterable object (i.e that can be
 * traversed with the `for..of` loop).
 *
 * Note that this matcher works fine with custom equality matchers.
 *
 * @message Expect [actual] (not) to contains only falsy values
 * @example
 *   expect([0, false, null, undefined, '']).toContainsOnlyFalsyValues();
 *
 *   expect([1, false, null, undefined, '']).not.toContainsOnlyFalsyValues();
 *   expect([0, true, null, undefined, '']).not.toContainsOnlyFalsyValues();
 *   expect([0, false, {}, undefined, '']).not.toContainsOnlyFalsyValues();
 *   expect([0, false, null, [], '']).not.toContainsOnlyFalsyValues();
 *   expect([0, false, null, undefined, 'foo']).not.toContainsOnlyFalsyValues();
 *
 * @param {Object} ctx Test context.
 * @return {Object} Test result.
 * @since 0.1.0
 */
export function toContainsOnlyFalsyValues({actual, pp}) {
  return {
    pass: isArray(actual) && every(actual, isFalsy),
    message() {
      return `Expect ${pp(actual)} {{not}} to contains only falsy values`;
    },
  };
}


text:
"""Command for deleting sole-tenancy hosts."""
from googlecloudsdk.api_lib.compute import base_classes

class Delete(base_classes.ZonalDeleter):
  """Delete Google Compute Engine sole-tenancy hosts.

  *{command}* deletes one or more Google Compute Engine
  sole-tenancy hosts. Hosts can be deleted only if they are not
  being used by any virtual machine instances.
  """

  @property
  def service(self):
    return self.compute.hosts

  @property
  def resource_type(self):
    return 'hosts'

  @property
  def custom_prompt(self):
    return ('The following hosts will be deleted. Deleting a host is '
            'irreversible and any data on the host will be lost.')

  @staticmethod
  def Args(parser):
    base_classes.ZonalDeleter.Args(parser, 'compute.hosts')


text:
package io.github.ratismal.felineutilities.api.blocks;

import net.minecraft.block.Block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.block.material.Material;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;

/**
 * Created by Ratismal on 2015-09-17.
 */

public class BaseBlockContainer extends BaseBlock implements ITileEntityProvider {

    public BaseBlockContainer(Material material) {
        super(material);
        this.isBlockContainer = true;
    }

    public BaseBlockContainer() {
        super(Material.rock);
        this.isBlockContainer = true;
    }

    @Override
    public TileEntity createNewTileEntity(World p_149915_1_, int p_149915_2_) {
        return null;
    }

    public void onBlockAdded(World world, int x, int y, int z) {
        super.onBlockAdded(world, x, y, z);
    }

    public void breakBlock(World world, int x, int y, int z, Block block, int meta) {
        super.breakBlock(world, x, y, z, block, meta);
    }

    public boolean onBlockEventReceved(World world, int x, int y, int z, int par1, int par2) {
        super.onBlockEventReceived(world, x, y, z, par1, par2);
        TileEntity tileEntity = world.getTileEntity(x, y, z);
        return tileEntity != null && tileEntity.receiveClientEvent(par1, par2);
    }
}


text:
using PaymillWrapper.Models;
using PaymillWrapper.Service;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using PaymillWrapper;

namespace WebApplication
{
    public partial class _Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (IsPostBack == false)
            {
            }
        }

        protected void btnSubmit_Click(object sender, EventArgs e)
        {
            if (IsValid)
            {
                PaymillContext paymill = new PaymillContext("YOUR PRIVATE KEY");
                String token = hToken.Value;
                Payment payment = paymill.PaymentService.CreateWithTokenAsync(token).Result;
                int amount = int.Parse(tbAmount.Text)*100;
                Transaction transaction = paymill.TransactionService.CreateWithPaymentAsync(payment, amount, tbCurrency.Text, "Test API c#").Result;
                /// Yout Transaction Is Complete
            }
        }

    }
}


text:
#ifndef GrAtlasTextBlob_DEFINED
#define GrAtlasTextBlob_DEFINED

#include "GrBatchAtlas.h"
#include "GrBatchFontCache.h"
#include "GrColor.h"
#include "SkDescriptor.h"
#include "SkMaskFilter.h"
#include "GrMemoryPool.h"
#include "SkSurfaceProps.h"
#include "SkTInternalLList.h"

// With this flag enabled, the GrAtlasTextContext will, as a sanity check, regenerate every blob
// that comes in to verify the integrity of its cache
//#define CACHE_SANITY_CHECK // VERY SLOW

/*
 * A GrAtlasTextBlob contains a fully processed SkTextBlob, suitable for nearly immediate drawing
 * on the GPU.  These are initially created with valid positions and colors, but invalid
 * texture coordinates.  The GrAtlasTextBlob itself has a few Blob-wide properties, and also
 * consists of a number of runs.  Runs inside a blob are flushed individually so they can be
 * reordered.
 *
 * The only thing(aside from a memcopy) required to flush a GrAtlasTextBlob is to ensure that
 * the GrAtlas will not evict anything the Blob needs.
 *
 * Note: This struct should really be named GrCachedAtasTextBlob, but that is too verbose.
 *
 * *WARNING* If you add new fields to this struct, then you may need to to update AssertEqual
 */
struct GrAtlasTextBlob : public SkRefCnt {
    SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrAtlasTextBlob);

    /*
     * Each Run inside of the blob can have its texture coordinates regenerated if required.
     * To determine if regeneration is necessary, fAtlasGeneration is used.  If there have been
     * any evictions inside of the atlas, then we will simply regenerate Runs.  We could track
     * this at a more fine grained level, but its not clear if this is worth it, as evictions
     * should be fairly rare.
     *
     * One additional point, each run can contain glyphs with any of the three mask formats.
     * We call these SubRuns.  Because a subrun must be a contiguous range, we have to create
     * a new subrun each time the mask format changes in a run.  In theory, a run can have as
     * many SubRuns as it has glyphs, ie if a run alternates between color emoji and A8.  In
     * practice, the vast majority of runs have only a single subrun.
     *
     * Finally, for runs where the entire thing is too large for the GrAtlasTextContext to
     * handle, we have a bit to mark the run as flusahable via rendering as paths.  It is worth
     * pointing. It would be a bit expensive to figure out ahead of time whether or not a run
     * can flush in this manner, so we always allocate vertices for the run, regardless of
     * whether or not it is too large.  The benefit of this strategy is that we can always reuse
     * a blob allocation regardless of viewmatrix changes.  We could store positions for these
     * glyphs.  However, its not clear if this is a win because we'd still have to either go the
     * glyph cache to get the path at flush time, or hold onto the path in the cache, which
     * would greatly increase the memory of these cached items.
     */
    struct Run {
        Run()
            : fColor(GrColor_ILLEGAL)
            , fInitialized(false)
            , fDrawAsPaths(false) {
            fVertexBounds.setLargestInverted();
            // To ensure we always have one subrun, we push back a fresh run here
            fSubRunInfo.push_back();
        }
        struct SubRunInfo {
            SubRunInfo()
                : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration)
                , fVertexStartIndex(0)
                , fVertexEndIndex(0)
                , fGlyphStartIndex(0)
                , fGlyphEndIndex(0)
                , fTextRatio(1.0f)
                , fMaskFormat(kA8_GrMaskFormat)
                , fDrawAsDistanceFields(false)
                , fUseLCDText(false) {}
            SubRunInfo(const SubRunInfo& that)
                : fBulkUseToken(that.fBulkUseToken)
                , fStrike(SkSafeRef(that.fStrike.get()))
                , fAtlasGeneration(that.fAtlasGeneration)
                , fVertexStartIndex(that.fVertexStartIndex)
                , fVertexEndIndex(that.fVertexEndIndex)
                , fGlyphStartIndex(that.fGlyphStartIndex)
                , fGlyphEndIndex(that.fGlyphEndIndex)
                , fTextRatio(that.fTextRatio)
                , fMaskFormat(that.fMaskFormat)
                , fDrawAsDistanceFields(that.fDrawAsDistanceFields)
                , fUseLCDText(that.fUseLCDText) {
            }
            // Distance field text cannot draw coloremoji, and so has to fall back.  However,
            // though the distance field text and the coloremoji may share the same run, they
            // will have different descriptors.  If fOverrideDescriptor is non-nullptr, then it
            // will be used in place of the run's descriptor to regen texture coords
            // TODO we could have a descriptor cache, it would reduce the size of these blobs
            // significantly, and then the subrun could just have a refed pointer to the
            // correct descriptor.
            GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
            SkAutoTUnref<GrBatchTextStrike> fStrike;
            uint64_t fAtlasGeneration;
            size_t fVertexStartIndex;
            size_t fVertexEndIndex;
            uint32_t fGlyphStartIndex;
            uint32_t fGlyphEndIndex;
            SkScalar fTextRatio; // df property
            GrMaskFormat fMaskFormat;
            bool fDrawAsDistanceFields; // df property
            bool fUseLCDText; // df property
        };

        SubRunInfo& push_back() {
            // Forward glyph / vertex information to seed the new sub run
            SubRunInfo& newSubRun = fSubRunInfo.push_back();
            SubRunInfo& prevSubRun = fSubRunInfo.fromBack(1);

            newSubRun.fGlyphStartIndex = prevSubRun.fGlyphEndIndex;
            newSubRun.fGlyphEndIndex = prevSubRun.fGlyphEndIndex;

            newSubRun.fVertexStartIndex = prevSubRun.fVertexEndIndex;
            newSubRun.fVertexEndIndex = prevSubRun.fVertexEndIndex;
            return newSubRun;
        }
        static const int kMinSubRuns = 1;
        SkAutoTUnref<SkTypeface> fTypeface;
        SkRect fVertexBounds;
        SkSTArray<kMinSubRuns, SubRunInfo> fSubRunInfo;
        SkAutoDescriptor fDescriptor;
        SkAutoTDelete<SkAutoDescriptor> fOverrideDescriptor; // df properties
        GrColor fColor;
        bool fInitialized;
        bool fDrawAsPaths;
    };

    struct BigGlyph {
        BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy, SkScalar scale, bool applyVM)
            : fPath(path)
            , fVx(vx)
            , fVy(vy)
            , fScale(scale)
            , fApplyVM(applyVM) {}
        SkPath fPath;
        SkScalar fVx;
        SkScalar fVy;
        SkScalar fScale;
        bool fApplyVM;
    };

    struct Key {
        Key() {
            sk_bzero(this, sizeof(Key));
        }
        uint32_t fUniqueID;
        // Color may affect the gamma of the mask we generate, but in a fairly limited way.
        // Each color is assigned to on of a fixed number of buckets based on its
        // luminance. For each luminance bucket there is a "canonical color" that
        // represents the bucket.  This functionality is currently only supported for A8
        SkColor fCanonicalColor;
        SkPaint::Style fStyle;
        SkPixelGeometry fPixelGeometry;
        bool fHasBlur;

        bool operator==(const Key& other) const {
            return 0 == memcmp(this, &other, sizeof(Key));
        }
    };

    struct StrokeInfo {
        SkScalar fFrameWidth;
        SkScalar fMiterLimit;
        SkPaint::Join fJoin;
    };

    enum TextType {
        kHasDistanceField_TextType = 0x1,
        kHasBitmap_TextType = 0x2,
    };

    // all glyph / vertex offsets are into these pools.
    unsigned char* fVertices;
    GrGlyph** fGlyphs;
    Run* fRuns;
    GrMemoryPool* fPool;
    SkMaskFilter::BlurRec fBlurRec;
    StrokeInfo fStrokeInfo;
    SkTArray<BigGlyph> fBigGlyphs;
    Key fKey;
    SkMatrix fViewMatrix;
    GrColor fPaintColor;
    SkScalar fX;
    SkScalar fY;

    // We can reuse distance field text, but only if the new viewmatrix would not result in
    // a mip change.  Because there can be multiple runs in a blob, we track the overall
    // maximum minimum scale, and minimum maximum scale, we can support before we need to regen
    SkScalar fMaxMinScale;
    SkScalar fMinMaxScale;
    int fRunCount;
    uint8_t fTextType;

    GrAtlasTextBlob()
        : fMaxMinScale(-SK_ScalarMax)
        , fMinMaxScale(SK_ScalarMax)
        , fTextType(0) {}

    ~GrAtlasTextBlob() override {
        for (int i = 0; i < fRunCount; i++) {
            fRuns[i].~Run();
        }
    }

    static const Key& GetKey(const GrAtlasTextBlob& blob) {
        return blob.fKey;
    }

    static uint32_t Hash(const Key& key) {
        return SkChecksum::Murmur3(&key, sizeof(Key));
    }

    void operator delete(void* p) {
        GrAtlasTextBlob* blob = reinterpret_cast<GrAtlasTextBlob*>(p);
        blob->fPool->release(p);
    }
    void* operator new(size_t) {
        SkFAIL("All blobs are created by placement new.");
        return sk_malloc_throw(0);
    }

    void* operator new(size_t, void* p) { return p; }
    void operator delete(void* target, void* placement) {
        ::operator delete(target, placement);
    }

    bool hasDistanceField() const { return SkToBool(fTextType & kHasDistanceField_TextType); }
    bool hasBitmap() const { return SkToBool(fTextType & kHasBitmap_TextType); }
    void setHasDistanceField() { fTextType |= kHasDistanceField_TextType; }
    void setHasBitmap() { fTextType |= kHasBitmap_TextType; }

#ifdef CACHE_SANITY_CHECK
    static void AssertEqual(const GrAtlasTextBlob&, const GrAtlasTextBlob&);
    size_t fSize;
#endif
};

#endif


text:
@interface BLAboutViewController () <BLLinkLabelDelegate>

@end

@implementation BLAboutViewController

- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil
{
    self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
    if (self) {
        // Custom initialization
    }
    return self;
}

- (void)viewDidLoad
{
    [super viewDidLoad];

    [self.mm_drawerController setMaximumLeftDrawerWidth:320.0f];
    [self.mm_drawerController setCloseDrawerGestureModeMask:MMCloseDrawerGestureModeNone];
	//背景图片
    [self.view setBackgroundColor:RGB(1, 178, 249)];

    //左边按钮
    CGRect viewFrame = CGRectZero;
    NSString *path = [[NSBundle mainBundle] pathForResource:@"left@2x" ofType:@"png"];
    UIImage *image = [UIImage imageWithContentsOfFile:path];
    viewFrame.origin.x = 10;
    viewFrame.origin.y = 15;
    viewFrame.size = image.size;
    UIButton *leftBtn = [[UIButton alloc] initWithFrame:viewFrame];
    [leftBtn setBackgroundColor:[UIColor clearColor]];
    [leftBtn setImage:image forState:UIControlStateNormal];
    [leftBtn addTarget:self action:@selector(leftBtnClicked:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:leftBtn];

    //标题
    viewFrame.origin.x = leftBtn.frame.size.width + leftBtn.frame.origin.x;
    viewFrame.origin.y = leftBtn.frame.origin.y;
    viewFrame.size.height = leftBtn.frame.size.height;
    viewFrame.size.width = self.view.frame.size.width - (leftBtn.frame.size.width + leftBtn.frame.origin.x) * 2;
    UILabel *label = [[UILabel alloc] initWithFrame:viewFrame];
    [label setTextColor:[UIColor whiteColor]];
    [label setBackgroundColor:[UIColor clearColor]];
    [label setText:NSLocalizedString(@"AboutTitle", nil)];
    [label setNumberOfLines:1];
    [label setTextAlignment:NSTextAlignmentCenter];
    [self.view addSubview:label];

    //图标
    viewFrame = CGRectZero;
    path = [[NSBundle mainBundle] pathForResource:@"home_logo@2x" ofType:@"png"];
    image = [UIImage imageWithContentsOfFile:path];
    viewFrame.origin.y = leftBtn.frame.size.height + leftBtn.frame.origin.y + 50.0f;
    viewFrame.origin.x = (self.view.frame.size.width - image.size.width) / 2.0f;
    viewFrame.size = image.size;
    UIImageView *logoImageView = [[UIImageView alloc] initWithFrame:viewFrame];
    [logoImageView setImage:image];
    [logoImageView.layer setCornerRadius:10.0f];
    [logoImageView.layer setMasksToBounds:YES];
    [self.view addSubview:logoImageView];

//    viewFrame = logoImageView.frame;
//    viewFrame.origin.x = 0.0f;
//    viewFrame.origin.y += viewFrame.size.height + 5.0f;
//    viewFrame.size = CGSizeMake(self.view.frame.size.width, 22.0f);
//    UILabel *versionLabel = [[UILabel alloc] initWithFrame:CGRectZero];
//    [versionLabel setBackgroundColor:[UIColor clearColor]];
//    [versionLabel setTextColor:[UIColor whiteColor]];
//    [versionLabel setTextAlignment:NSTextAlignmentCenter];
//    [versionLabel setFont:[UIFont systemFontOfSize:14.0f]];
//    [versionLabel setText:NSLocalizedString(@"APPVersion", nil)];
//    viewFrame = [versionLabel textRectForBounds:viewFrame limitedToNumberOfLines:1];
//    viewFrame.origin.x = (self.view.frame.size.width - viewFrame.size.width) / 2.0f;
//    [versionLabel setFrame:viewFrame];
//    [self.view addSubview:versionLabel];

    //服务电话
    viewFrame.origin.x = 0;
    viewFrame.origin.y = self.view.frame.size.height - 140.0f - 2;
    viewFrame.size = CGSizeMake(self.view.frame.size.width, 22.0f);
    UILabel *serviceLabel = [[UILabel alloc] initWithFrame:viewFrame];
    [serviceLabel setBackgroundColor:[UIColor clearColor]];
    [serviceLabel setText:NSLocalizedString(@"FilterInfoViewControllerServicePhoneLabel", nil)];
    [serviceLabel setTextColor:[UIColor whiteColor]];
    [serviceLabel setFont:[UIFont systemFontOfSize:13.f]];
    [serviceLabel setTextAlignment:NSTextAlignmentCenter];
    CGSize size = [serviceLabel.text sizeWithFont:[UIFont systemFontOfSize:15.f] constrainedToSize:CGSizeMake(MAXFLOAT, serviceLabel.frame.size.height) lineBreakMode:NSLineBreakByWordWrapping];
    viewFrame.size.width = size.width;
    [serviceLabel setFrame:viewFrame];
    [self.view addSubview:serviceLabel];
    //号码内容
    viewFrame.origin.x = serviceLabel.frame.size.width + serviceLabel.frame.origin.x;
    viewFrame.origin.y = self.view.frame.size.height - 140.0f;
    viewFrame.size = CGSizeMake(self.view.frame.size.width, 22.0f);
    BLLinkLabel *phoneLabel = [[BLLinkLabel alloc] initWithFrame:CGRectZero];
    [phoneLabel setBackgroundColor:[UIColor clearColor]];
    [phoneLabel setTextColor:[UIColor blueColor]];
    [phoneLabel setHighlightedTextColor:[UIColor grayColor]];
    [phoneLabel setDelegate:self];
    [phoneLabel setFont:[UIFont systemFontOfSize:14.0f]];
    [phoneLabel setText:NSLocalizedString(@"FilterInfoViewControllerPhoneNumberLabel", nil)];
    [phoneLabel setTag:999 * 1];
    viewFrame = [phoneLabel textRectForBounds:viewFrame limitedToNumberOfLines:1];
    [phoneLabel setFrame:viewFrame];
    [self.view addSubview:phoneLabel];
    [serviceLabel setFrame:CGRectMake((self.view.frame.size.width - phoneLabel.frame.size.width - serviceLabel.frame.size.width) / 2.f, serviceLabel.frame.origin.y, serviceLabel.frame.size.width, serviceLabel.frame.size.height)];
    [phoneLabel setFrame:CGRectMake(serviceLabel.frame.size.width + serviceLabel.frame.origin.x, phoneLabel.frame.origin.y, phoneLabel.frame.size.width, phoneLabel.frame.size.height)];
    //公司名称
    viewFrame = phoneLabel.frame;
    viewFrame.origin.y += viewFrame.size.height + 15.0f;
    viewFrame.size = CGSizeMake(self.view.frame.size.width, 22.0f);
    UILabel *companyLabel = [[UILabel alloc] initWithFrame:CGRectZero];
    [companyLabel setBackgroundColor:[UIColor clearColor]];
    [companyLabel setTextColor:[UIColor whiteColor]];
    [companyLabel setTextAlignment:NSTextAlignmentCenter];
    [companyLabel setFont:[UIFont systemFontOfSize:15.0f]];
    [companyLabel setText:NSLocalizedString(@"FilterInfoViewControllerAddress", nil)];
    viewFrame = [companyLabel textRectForBounds:viewFrame limitedToNumberOfLines:1];
    viewFrame.origin.x = (self.view.frame.size.width - viewFrame.size.width) / 2.0f;
    [companyLabel setFrame:viewFrame];
    [self.view addSubview:companyLabel];
    //网址
    viewFrame = companyLabel.frame;
    viewFrame.origin.y += viewFrame.size.height + 15.0f;
    viewFrame.size = CGSizeMake(self.view.frame.size.width, 22.0f);
    BLLinkLabel *webSiteLabel = [[BLLinkLabel alloc] initWithFrame:CGRectZero];
    [webSiteLabel setDelegate:self];
    [webSiteLabel setHighlightedTextColor:[UIColor grayColor]];
    [webSiteLabel setTag:999 * 2];
    [webSiteLabel setBackgroundColor:[UIColor clearColor]];
    [webSiteLabel setTextColor:[UIColor blueColor]];
    [webSiteLabel setTextAlignment:NSTextAlignmentCenter];
    [webSiteLabel setFont:[UIFont systemFontOfSize:13.0f]];
    [webSiteLabel setText:NSLocalizedString(@"FilterInfoViewControllerWebsiteAddress", nil)];
    viewFrame = [webSiteLabel textRectForBounds:viewFrame limitedToNumberOfLines:1];
    viewFrame.origin.x = (self.view.frame.size.width - viewFrame.size.width) / 2.0f;
    [webSiteLabel setFrame:viewFrame];
    [self.view addSubview:webSiteLabel];

    viewFrame = webSiteLabel.frame;
    viewFrame.origin.y += viewFrame.size.height + 15.0f;
    viewFrame.size = CGSizeMake(self.view.frame.size.width, 44.0f);
    UILabel *addressLabel = [[UILabel alloc] initWithFrame:CGRectZero];
    [addressLabel setBackgroundColor:[UIColor clearColor]];
    [addressLabel setTextColor:[UIColor whiteColor]];
    [addressLabel setFont:[UIFont systemFontOfSize:11.0f]];
    [addressLabel setTextAlignment:NSTextAlignmentCenter];
    [addressLabel setText:NSLocalizedString(@"FilterInfoViewControllerCompanyAddress", nil)];
    [addressLabel setNumberOfLines:2];
    viewFrame = [addressLabel textRectForBounds:viewFrame limitedToNumberOfLines:2];
    viewFrame.origin.x = (self.view.frame.size.width - viewFrame.size.width) / 2.0f;
    [addressLabel setFrame:viewFrame];
    [addressLabel setTextAlignment:NSTextAlignmentCenter];
    [self.view addSubview:addressLabel];
}

-(void)leftBtnClicked:(UIButton *)button
{
    [self.mm_drawerController setMaximumLeftDrawerWidth:280.0f];
    [self.mm_drawerController setCloseDrawerGestureModeMask:MMCloseDrawerGestureModeAll];
    [self.navigationController popViewControllerAnimated:YES];
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

#pragma mark -
#pragma mark - BLLinkLabel Delegate
- (void)linkLabel:(BLLinkLabel *)label touchesWithTag:(NSInteger)tag
{
    if (tag == 999 * 1)
    {
        UIWebView *callWebView = [[UIWebView alloc] init];
        NSURL *url = [NSURL URLWithString:@"tel://+86-0512-62925562"];
        [callWebView loadRequest:[NSURLRequest requestWithURL:url]];
        [self.view addSubview:callWebView];
    }
    else if (tag == 999 * 2)
    {
        [[UIApplication sharedApplication] openURL:[NSURL URLWithString:label.text]];
    }
}

@end


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

        <META http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <TITLE>
            org.encog.ca (Encog Core 3.2.0-SNAPSHOT API)
        </TITLE>

        <META NAME="date" CONTENT="2013-04-17">

        <LINK REL ="stylesheet" TYPE="text/css" HREF="../../../stylesheet.css" TITLE="Style">

            org.encog.ca

                        Exceptions

                        CellularAutomataError