text:
#if defined(__unix__) || defined(__APPLE__) || defined(__linux__)
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <unistd.h>
#endif

#ifdef _SC_PAGESIZE
#define PAGE_SIZE sysconf(_SC_PAGESIZE)
#else
#define PAGE_SIZE 4096
#endif

#include <fiobject.h>

#include <fio_siphash.h>
#include <fiobj_numbers.h>
#include <fiobj_str.h>

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <string.h>
#include <sys/stat.h>

#define FIO_INCLUDE_STR
#define FIO_STR_NO_REF
#include <fio.h>

#ifndef PATH_MAX
#define PATH_MAX PAGE_SIZE
#endif

/* *****************************************************************************
String Type
***************************************************************************** */

typedef struct {
  fiobj_object_header_s head;
  uint64_t hash;
  fio_str_s str;
} fiobj_str_s;

#define obj2str(o) ((fiobj_str_s *)(FIOBJ2PTR(o)))

static inline fio_str_info_s fiobj_str_get_cstr(const FIOBJ o) {
  return fio_str_info(&obj2str(o)->str);
}

/* *****************************************************************************
String VTables
***************************************************************************** */

static fio_str_info_s fio_str2str(const FIOBJ o) {
  return fiobj_str_get_cstr(o);
}

static void fiobj_str_dealloc(FIOBJ o, void (*task)(FIOBJ, void *), void *arg) {
  fio_str_free(&obj2str(o)->str);
  fio_free(FIOBJ2PTR(o));
  (void)task;
  (void)arg;
}

static size_t fiobj_str_is_eq(const FIOBJ self, const FIOBJ other) {
  return fio_str_iseq(&obj2str(self)->str, &obj2str(other)->str);
}

static intptr_t fio_str2i(const FIOBJ o) {
  char *pos = fio_str_data(&obj2str(o)->str);
  return fio_atol(&pos);
}
static double fio_str2f(const FIOBJ o) {
  char *pos = fio_str_data(&obj2str(o)->str);
  return fio_atof(&pos);
}

static size_t fio_str2bool(const FIOBJ o) {
  return fio_str_len(&obj2str(o)->str) != 0;
}

uintptr_t fiobject___noop_count(const FIOBJ o);

const fiobj_object_vtable_s FIOBJECT_VTABLE_STRING = {
    .class_name = "String",
    .dealloc = fiobj_str_dealloc,
    .to_i = fio_str2i,
    .to_f = fio_str2f,
    .to_str = fio_str2str,
    .is_eq = fiobj_str_is_eq,
    .is_true = fio_str2bool,
    .count = fiobject___noop_count,
};

/* *****************************************************************************
String API
***************************************************************************** */

/** Creates a buffer String object. Remember to use `fiobj_free`. */
FIOBJ fiobj_str_buf(size_t capa) {
  if (capa)
    capa = capa + 1;
  else
    capa = PAGE_SIZE;

  fiobj_str_s *s = fio_malloc(sizeof(*s));
  if (!s) {
    perror("ERROR: fiobj string couldn't allocate memory");
    exit(errno);
  }
  *s = (fiobj_str_s){
      .head =
          {
              .ref = 1,
              .type = FIOBJ_T_STRING,
          },
      .str = FIO_STR_INIT,
  };
  if (capa) {
    fio_str_capa_assert(&s->str, capa);
  }
  return ((uintptr_t)s | FIOBJECT_STRING_FLAG);
}

/** Creates a String object. Remember to use `fiobj_free`. */
FIOBJ fiobj_str_new(const char *str, size_t len) {
  fiobj_str_s *s = fio_malloc(sizeof(*s));
  if (!s) {
    perror("ERROR: fiobj string couldn't allocate memory");
    exit(errno);
  }
  *s = (fiobj_str_s){
      .head =
          {
              .ref = 1,
              .type = FIOBJ_T_STRING,
          },
      .str = FIO_STR_INIT,
  };
  if (str && len) {
    fio_str_write(&s->str, str, len);
  }
  return ((uintptr_t)s | FIOBJECT_STRING_FLAG);
}

/**
 * Creates a String object. Remember to use `fiobj_free`.
 *
 * It's possible to wrap a previously allocated memory block in a FIOBJ String
 * object, as long as it was allocated using `fio_malloc`.
 *
 * The ownership of the memory indicated by `str` will "move" to the object and
 * will be freed (using `fio_free`) once the object's reference count drops to
 * zero.
 */
FIOBJ fiobj_str_move(char *str, size_t len, size_t capacity) {
  fiobj_str_s *s = fio_malloc(sizeof(*s));
  if (!s) {
    perror("ERROR: fiobj string couldn't allocate memory");
    exit(errno);
  }
  *s = (fiobj_str_s){
      .head =
          {
              .ref = 1,
              .type = FIOBJ_T_STRING,
          },
      .str = FIO_STR_INIT_EXISTING(str, len, capacity),
  };
  return ((uintptr_t)s | FIOBJECT_STRING_FLAG);
}

/**
 * Returns a thread-static temporary string. Avoid calling `fiobj_dup` or
 * `fiobj_free`.
 */
FIOBJ fiobj_str_tmp(void) {
  static __thread fiobj_str_s tmp = {
      .head =
          {
              .ref = ((~(uint32_t)0) >> 4),
              .type = FIOBJ_T_STRING,
          },
      .str = {.small = 1},
  };
  tmp.str.frozen = 0;
  fio_str_resize(&tmp.str, 0);
  return ((uintptr_t)&tmp | FIOBJECT_STRING_FLAG);
}

/** Prevents the String object from being changed. */
void fiobj_str_freeze(FIOBJ str) {
  if (FIOBJ_TYPE_IS(str, FIOBJ_T_STRING))
    fio_str_freeze(&obj2str(str)->str);
}

/** Confirms the requested capacity is available and allocates as required. */
size_t fiobj_str_capa_assert(FIOBJ str, size_t size) {

  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
  if (obj2str(str)->str.frozen)
    return 0;
  fio_str_info_s state = fio_str_capa_assert(&obj2str(str)->str, size);
  return state.capa;
}

/** Return's a String's capacity, if any. */
size_t fiobj_str_capa(FIOBJ str) {
  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
  return fio_str_capa(&obj2str(str)->str);
}

/** Resizes a String object, allocating more memory if required. */
void fiobj_str_resize(FIOBJ str, size_t size) {
  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
  fio_str_resize(&obj2str(str)->str, size);
  obj2str(str)->hash = 0;
  return;
}

/** Deallocates any unnecessary memory (if supported by OS). */
void fiobj_str_compact(FIOBJ str) {
  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
  fio_str_compact(&obj2str(str)->str);
  return;
}

/** Empties a String's data. */
void fiobj_str_clear(FIOBJ str) {
  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
  fio_str_resize(&obj2str(str)->str, 0);
  obj2str(str)->hash = 0;
}

/**
 * Writes data at the end of the string, resizing the string as required.
 * Returns the new length of the String
 */
size_t fiobj_str_write(FIOBJ dest, const char *data, size_t len) {
  assert(FIOBJ_TYPE_IS(dest, FIOBJ_T_STRING));
  if (obj2str(dest)->str.frozen)
    return 0;
  obj2str(dest)->hash = 0;
  return fio_str_write(&obj2str(dest)->str, data, len).len;
}

/**
 * Writes a number at the end of the String using normal base 10 notation.
 *
 * Returns the new length of the String
 */
size_t fiobj_str_write_i(FIOBJ dest, int64_t num) {
  assert(FIOBJ_TYPE_IS(dest, FIOBJ_T_STRING));
  if (obj2str(dest)->str.frozen)
    return 0;
  obj2str(dest)->hash = 0;
  return fio_str_write_i(&obj2str(dest)->str, num).len;
}

/**
 * Writes data at the end of the string, resizing the string as required.
 * Returns the new length of the String
 */
size_t fiobj_str_printf(FIOBJ dest, const char *format, ...) {
  assert(FIOBJ_TYPE_IS(dest, FIOBJ_T_STRING));
  if (obj2str(dest)->str.frozen)
    return 0;
  obj2str(dest)->hash = 0;
  va_list argv;
  va_start(argv, format);
  fio_str_info_s state = fio_str_vprintf(&obj2str(dest)->str, format, argv);
  va_end(argv);
  return state.len;
}

size_t fiobj_str_vprintf(FIOBJ dest, const char *format, va_list argv) {
  assert(FIOBJ_TYPE_IS(dest, FIOBJ_T_STRING));
  if (obj2str(dest)->str.frozen)
    return 0;
  obj2str(dest)->hash = 0;
  fio_str_info_s state = fio_str_vprintf(&obj2str(dest)->str, format, argv);
  return state.len;
}

/** Dumps the `filename` file's contents at the end of a String. If `limit ==
 * 0`, than the data will be read until EOF.
 *
 * If the file can't be located, opened or read, or if `start_at` is beyond
 * the EOF position, NULL is returned.
 *
 * Remember to use `fiobj_free`.
 */
size_t fiobj_str_readfile(FIOBJ dest, const char *filename, intptr_t start_at,
                          intptr_t limit) {
  fio_str_info_s state =
      fio_str_readfile(&obj2str(dest)->str, filename, start_at, limit);
  return state.len;
}

/**
 * Writes data at the end of the string, resizing the string as required.
 * Returns the new length of the String
 */
size_t fiobj_str_concat(FIOBJ dest, FIOBJ obj) {
  assert(FIOBJ_TYPE_IS(dest, FIOBJ_T_STRING));
  if (obj2str(dest)->str.frozen)
    return 0;
  obj2str(dest)->hash = 0;
  fio_str_info_s o = fiobj_obj2cstr(obj);
  if (o.len == 0)
    return fio_str_len(&obj2str(dest)->str);
  return fio_str_write(&obj2str(dest)->str, o.data, o.len).len;
}

/**
 * Calculates a String's SipHash value for use as a HashMap key.
 */
uint64_t fiobj_str_hash(FIOBJ o) {
  assert(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING));
  // if (obj2str(o)->is_small) {
  //   return fiobj_hash_string(STR_INTENAL_STR(o), STR_INTENAL_LEN(o));
  // } else
  if (obj2str(o)->hash) {
    return obj2str(o)->hash;
  }
  fio_str_info_s state = fio_str_info(&obj2str(o)->str);
  obj2str(o)->hash = fiobj_hash_string(state.data, state.len);
  return obj2str(o)->hash;
}

/* *****************************************************************************
Tests
***************************************************************************** */

#if DEBUG
void fiobj_test_string(void) {
  fprintf(stderr, "=== Testing Strings\n");
  fprintf(stderr, "* Internal String Capacity %u \n",
          (unsigned int)FIO_STR_SMALL_CAPA);
#define TEST_ASSERT(cond, ...)                                                 \
  if (!(cond)) {                                                               \
    fprintf(stderr, "* " __VA_ARGS__);                                         \
    fprintf(stderr, "Testing failed.\n");                                      \
    exit(-1);                                                                  \
  }
#define STR_EQ(o, str)                                                         \
  TEST_ASSERT((fiobj_str_getlen(o) == strlen(str) &&                           \
               !memcmp(fiobj_str_mem_addr(o), str, strlen(str))),              \
              "String not equal to " str)
  FIOBJ o = fiobj_str_new("Hello", 5);
  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING), "Small String isn't string!\n");
  TEST_ASSERT(obj2str(o)->str.small, "Hello isn't small\n");
  fiobj_str_write(o, " World", 6);
  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING),
              "Hello World String isn't string!\n");
  TEST_ASSERT(obj2str(o)->str.small, "Hello World isn't small\n");
  TEST_ASSERT(fiobj_obj2cstr(o).len == 11,
              "Invalid small string length (%u != 11)!\n",
              (unsigned int)fiobj_obj2cstr(o).len)
  fiobj_str_write(o, " World, you crazy longer sleep loving person :-)", 48);
  TEST_ASSERT(!obj2str(o)->str.small, "Crazier shouldn't be small\n");
  fiobj_free(o);

  o = fiobj_str_new(
      "hello my dear friend, I hope that your are well and happy.", 58);
  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING), "Long String isn't string!\n");
  TEST_ASSERT(!obj2str(o)->str.small,
              "Long String is small! (capa: %lu, len: %lu)\n",
              fio_str_capa(&obj2str(o)->str), fio_str_len(&obj2str(o)->str));
  TEST_ASSERT(fiobj_obj2cstr(o).len == 58,
              "Invalid long string length (%lu != 58)!\n",
              fiobj_obj2cstr(o).len)
  uint64_t hash = fiobj_str_hash(o);
  TEST_ASSERT(!obj2str(o)->str.frozen, "String forzen when only hashing!\n");
  fiobj_str_freeze(o);
  TEST_ASSERT(obj2str(o)->str.frozen, "String not forzen!\n");
  fiobj_str_write(o, " World", 6);
  TEST_ASSERT(hash == fiobj_str_hash(o),
              "String hash changed after hashing - not frozen?\n");
  TEST_ASSERT(fiobj_obj2cstr(o).len == 58,
              "String was edited after hashing - not frozen!\n (%lu): %s",
              (unsigned long)fiobj_obj2cstr(o).len, fiobj_obj2cstr(o).data);
  fiobj_free(o);

  o = fiobj_str_buf(1);
  fiobj_str_printf(o, "%u", 42);
  TEST_ASSERT(fio_str_len(&obj2str(o)->str) == 2,
              "fiobj_strprintf length error.\n");
  TEST_ASSERT(fiobj_obj2num(o), "fiobj_strprintf integer error.\n");
  TEST_ASSERT(!memcmp(fiobj_obj2cstr(o).data, "42", 2),
              "fiobj_strprintf string error.\n");
  fiobj_free(o);

  o = fiobj_str_buf(4);
  for (int i = 0; i < 16000; ++i) {
    fiobj_str_write(o, "a", 1);
  }
  TEST_ASSERT(fio_str_len(&obj2str(o)->str) == 16000,
              "16K fiobj_str_write not 16K.\n");
  TEST_ASSERT(fio_str_capa(&obj2str(o)->str) >= 16000,
              "16K fiobj_str_write capa not enough.\n");
  fiobj_free(o);

  o = fiobj_str_buf(0);
  TEST_ASSERT(fiobj_str_readfile(o, __FILE__, 0, 0),
              "`fiobj_str_readfile` - file wasn't read!");
  TEST_ASSERT(!memcmp(fiobj_obj2cstr(o).data, "/*", 2),
              "`fiobj_str_readfile` error, start of file doesn't match:\n%s",
              fiobj_obj2cstr(o).data);
  fiobj_free(o);

  fprintf(stderr, "* passed.\n");
}
#endif


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>
RDFErrorHandler (Jena Framework)
</TITLE>

<META NAME="date" CONTENT="2010-12-12">

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

      Overview
      Package
    Class
      Use
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.hp.hpl.jena.rdf.model

Interface RDFErrorHandler

public interface RDFErrorHandler

A generic error handler.

Version:

$Revision: 1.1 $

Author:

bwm

Method Summary

 void
error(Exception e)

          report an error

 void
fatalError(Exception e)

          report a catastrophic error.

 void
warning(Exception e)

          report a warning

Method Detail

warning

void warning(Exception e)

report a warning

Parameters:
e - an exception representing the error

error

void error(Exception e)

report an error

Parameters:
e - an exception representing the error

fatalError

void fatalError(Exception e)

report a catastrophic error.  Must not return.

Parameters:
e - an exception representing the error

      Overview
      Package
    Class
      Use
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

Copyright ? 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Hewlett-Packard Development Company, LP

redpajama_set_name: RedPajamaGithub


text:
cask "font-delugia-book" do
  version "2111.01"
  sha256 "3eb0640c190a6b3ddba1a9176e63c2cc0515d9ec6c5f54cb1c6355062ce179c2"

  url "https://github.com/adam7/delugia-code/releases/download/v#{version}/delugia-book.zip"
  name "Delugia Code"
  desc "Cascadia Code + Nerd Fonts, minor difference between Caskaydia Cove Nerd Font"
  homepage "https://github.com/adam7/delugia-code"

  font "delugia-book/DelugiaBook-Bold.ttf"
  font "delugia-book/DelugiaBook-BoldItalic.ttf"
  font "delugia-book/DelugiaBook-Italic.ttf"
  font "delugia-book/DelugiaBook.ttf"
  font "delugia-book/DelugiaBookLight-Italic.ttf"
  font "delugia-book/DelugiaBookLight.ttf"
end


text:
var {
  GraphQLObjectType,
  GraphQLSchema,
  GraphQLList
} = require('graphql');
var CarType = require('../schemaTypes/carTypes');
let schema = new GraphQLSchema({
    query: new GraphQLObjectType({
        name: 'RootQueryType',
        fields: {
            cars: {
                type: new GraphQLList(CarType)
            }
        }
    }),
})

module.exports = schema;


text:
package com.webVault;

public class Gold extends YahooStock{

	// private constants
	public static final String ticker = "XAUUSD=X";

	public Gold(){
		super(ticker);
	}
}


text:
from celery.task import task
from django.core.mail import send_mail
from django.utils.translation import ugettext, ugettext_lazy as _

@task
def send_todo_alert(todo_alert, **kwargs):
    todo = todo_alert.todo
    user = todo_alert.owner
    if not user.email:
        return
    # TODO: Set a proper language and make a nice looking email.
    try:
        send_mail(
            subject=_('This is a reminder for one of todos from MarkItDone'),
            message=_('This is a reminder for todo {todo}. Its due time is {due_time}').format(todo=todo, due_time=todo.due_time),
            from_email=user.email,
            recipient_list=[user.email],
            fail_silently=False
        )
    except Exception, e:
        send_todo_alert.retry(args=[x, y], exc=e, countdown=180, kwargs=kwargs)


text:
require 'test_helper'
require 'ruby_postal/parser'

class RubyPostalParserTest < Minitest::Test
    def self.has_all_components(address, components)
        expected = components.length
        got = 0

        parsed = Postal::Parser.parse_address(address)
        parsed.each { |comp| got += components[comp[:label]] == comp[:value] ? 1 : 0}

        got == expected
    end

    def test_parser
        assert RubyPostalParserTest.has_all_components('781 Franklin Ave Crown Heights Brooklyn NYC NY 11216 USA', {
                :house_number => '781',
                :road => 'franklin ave',
                :suburb => 'crown heights',
                :city_district => 'brooklyn',
                :city => 'nyc',
                :state => 'ny',
                :postcode => '11216',
                :country => 'usa'

            })
    end

    def test_parse_nil
        assert_equal [], Postal::Parser.parse_address(nil)
    end

    def test_parse_non_string_raises_exception
        assert_raises ArgumentError do
            Postal::Parser.parse_address(["a", "b"])
            Postal::Parser.parse_address({"a" => "b"})
        end
    end

end


text:
This project contains globally useful, portable includes for augmenting the base functionality of the proprietary AMX NetLinx language used for programming [AMX NetLinx integrated controllers](http://www.amx.com/products/categoryCentralControllers.asp).

Currently the project provides a math library, string manipulation library, time and date library, array utils, a managed debug messaging library and an associated console output library.

# Contributors
[Kim Burgess](http://kimburgess.info)

[true](mailto:amx@trueserve.org)

[Jeff Spire](http://spireintegrated.com/)

[Jorde Vorstenbosch](mailto:jordevorstenbosch@gmail.com)

[Andy Dixon](https://github.com/PsyenceFact)

# Contributing

Want to help out? Awesome.

1. Fork it.
2. Make your changes / improvements / bug fixes etc (and ensure that you adhere to the [project style guide](https://github.com/KimBurgess/NetLinx-Common-Libraries/wiki/Code-Format-and-Commenting) whilst doing so).
3. Submit a pull request.
4. Win.

# Usage

A convenience include has been provided to simplify usage. Ensure that the libraries are placed within your project's compile path then include prior to utilizing provided functionality within your project code.

    include 'netlinx-common-libraries'

Alternatively, individually specify the library components that you require. Any cross include dependencies within the NetLinx Common Libraries are handled internally.

This project is licensed under the MIT License. Feel free to use it, sell it, modify it, re-distribute - basically whatever the hell you like. See [LICENSE](https://github.com/KimBurgess/NetLinx-Common-Libraries/blob/master/LICENSE) for more info.


text:
var chalk = require('chalk');
var yosay = require('yosay');
var changeCase = require('change-case');

module.exports = function(Generator) {
  Generator.prototype.prompts = function() {
    var done = this.async();

    // Have Yeoman greet the user.
    this.log(yosay(
      chalk.green('Angular Enterprise') + ' - Angular 1.4 generator!'
    ));

    var prompts = [
      {
        type: 'input',
        name: 'appName',
        message: 'Main application module name',
        default: 'app',
        store: true
      },
      {
        type: 'input',
        name: 'clientSideFolder',
        message: 'Folder for client-side code',
        default: 'client/',
        store: true
      },
      {
        type: 'input',
        name: 'appSubFolder',
        message: 'Sub-folder (in client-side folder) for application code',
        default: 'app/',
        store: true
      },
      {
        type: 'input',
        name: 'directivePrefix',
        message: 'Prefix added to all directives (see Y073 in style guide); enter nothing/space to skip this',
        store: true
      },
      {
        type: 'list',
        name: 'router',
        message: 'Which router would you like to use?',
        default: (this.config.get('uirouter') && 1) || 0,
        choices: ['Angular UI Router', 'Standard Angular Router']
      },
      {
        type: 'confirm',
        name: 'bootstrap',
        message: "Would you like Bootstrap?",
        default: true,
        store: true
      },
      {
        type: 'confirm',
        name: 'swagger',
        message: 'Would you like to mock your api with Swagger?',
        default: true,
        store: true
      }];

    this.prompt(prompts, function (choices) {
      this.choices = choices;
      this.choices.appName = changeCase.camelCase(this.choices.appName.trim());
      this.choices.clientSideFolder = changeCase.paramCase(this.choices.clientSideFolder.trim()).replace(/(.*?)\/$/, '$1') + '/';
      this.choices.clientSideFolderMinusSlash = this.choices.clientSideFolder.slice(0, -1);
      this.choices.directivePrefix = changeCase.camelCase(this.choices.directivePrefix.trim());
      this.choices.appSubFolder = changeCase.paramCase(this.choices.appSubFolder.trim()).replace(/(.*?)\/$/, '$1') + '/';
      if (choices.router === 'Angular UI Router') {
        this.choices.uirouter = true;
        this.choices.routerJs = 'bower_components/angular-ui-router/release/angular-ui-router.js';
        this.choices.routerModuleName = 'ui.router';
        this.choices.routerViewDirective = 'ui-view';
      } else {
        this.choices.uirouter = false;
        this.choices.routerJs = 'bower_components/angular-route/angular-route.js';
        this.choices.routerModuleName = 'ngRoute';
        this.choices.routerViewDirective = 'ng-view';
      }

      this.config.set('appName', this.choices.appName);
      this.config.set('clientSideFolder', this.choices.clientSideFolder);
      this.config.set('appSubFolder', this.choices.appSubFolder);
      this.config.set('directivePrefix', this.choices.directivePrefix);
      this.config.set('uirouter', this.choices.uirouter);
      this.config.set('swagger', this.choices.swagger);
      this.config.set('bootstrap', this.choices.bootstrap);

      done();
    }.bind(this));
  }
}


text:
using Autofac.Extras.FakeItEasy;
using Elasticsearch.Net.Connection;
using Elasticsearch.Net.Tests.Unit.Stubs;
using FakeItEasy;
using NUnit.Framework;

namespace Elasticsearch.Net.Tests.Unit.Failover.Retries
{
	[TestFixture]
	public class MaximumRetriesRetryHandlingTests
	{
		[Test]
		public void ShouldNotRetryWhenMaxRetriesIs0()
		{
			using (var fake = new AutoFake(callsDoNothing: true))
			{
				var connectionConfiguration = new ConnectionConfiguration().MaximumRetries(0);
				fake.Provide<IConnectionConfigurationValues>(connectionConfiguration);
				FakeCalls.ProvideDefaultTransport(fake);

				var getCall = FakeCalls.GetSyncCall(fake);
				getCall.Returns(FakeResponse.Bad(connectionConfiguration));

				var client = fake.Resolve<ElasticsearchClient>();

				Assert.DoesNotThrow(() => client.Info());
				getCall.MustHaveHappened(Repeated.Exactly.Once);

			}
		}

		[Test]
		public void ShouldNotRetryWhenMaxRetriesIs0_Async()
		{
			using (var fake = new AutoFake(callsDoNothing: true))
			{
				var connectionConfiguration = new ConnectionConfiguration().MaximumRetries(0);
				fake.Provide<IConnectionConfigurationValues>(connectionConfiguration);
				FakeCalls.ProvideDefaultTransport(fake);

				var getCall = FakeCalls.GetCall(fake);
				getCall.Returns(FakeResponse.Bad(connectionConfiguration));

				var client = fake.Resolve<ElasticsearchClient>();

				Assert.DoesNotThrow(async () => await client.InfoAsync());
				getCall.MustHaveHappened(Repeated.Exactly.Once);

			}
		}
	}
}


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=ISO-8859-1">
<title>ESCOGrouper online Help</title>

        Folder edition : Attributes

Dans cet onglet, l'utilisateur définit ou modifie les attributs du dossier. Trois informations sont nécessaires :

Extension : nom interne à Grouper du dossier ;

Extension affichée : nom du dossier qui sera affiché, notamment dans l'arborescence ;

Description : description du dossier, c'est un texte libre.

Sur un dossier, ces informations ne peuvent être modifiées que si l'utilisateur connecté possède les droits suffisants.


text:
using NuGet.Test.Mocks;
using Xunit;

namespace NuGet.VisualStudio.Test
{
    public class ProjectSystemExtensionsTest
    {
        [Fact]
        public void CreateRefreshFileAddsRefreshFileUnderBinDirectory()
        {
            // Arrange
            var projectSystem = new MockProjectSystem(VersionUtility.DefaultTargetFramework, @"x:\test\site\");
            var assemblyPath = @"x:\test\packages\Foo.1.0\lib\net40\Foo.dll";

            // Act
            projectSystem.CreateRefreshFile(assemblyPath);

            // Assert
            Assert.Equal(@"..\packages\Foo.1.0\lib\net40\Foo.dll", projectSystem.ReadAllText(@"bin\Foo.dll.refresh"));
        }

        [Fact]
        public void CreateRefreshFileUsesAbsolutePathIfRelativePathsCannotBeFormed()
        {
            // Arrange
            var projectSystem = new MockProjectSystem(VersionUtility.DefaultTargetFramework, @"z:\test\site\");
            var assemblyPath = @"x:\test\packages\Foo.1.0\lib\net40\Bar.net40.dll";

            // Act
            projectSystem.CreateRefreshFile(assemblyPath);

            // Assert
            Assert.Equal(@"x:\test\packages\Foo.1.0\lib\net40\Bar.net40.dll", projectSystem.ReadAllText(@"bin\Bar.net40.dll.refresh"));
        }
    }
}


text:
package validate

import (
	"fmt"
	"net"
	"regexp"
	"strconv"
	"strings"

	"github.com/lxc/lxd/shared/units"
)

// stringInSlice checks whether the supplied string is present in the supplied slice.
func stringInSlice(key string, list []string) bool {
	for _, entry := range list {
		if entry == key {
			return true
		}
	}
	return false
}

// Required returns function that runs one or more validators, all must pass without error.
func Required(validators ...func(value string) error) func(value string) error {
	return func(value string) error {
		for _, validator := range validators {
			err := validator(value)
			if err != nil {
				return err
			}
		}

		return nil
	}
}

// Optional wraps Required() function to make it return nil if value is empty string.
func Optional(validators ...func(value string) error) func(value string) error {
	return func(value string) error {
		if value == "" {
			return nil
		}

		return Required(validators...)(value)
	}
}

// IsInt64 validates whether the string can be converted to an int64.
func IsInt64(value string) error {
	_, err := strconv.ParseInt(value, 10, 64)
	if err != nil {
		return fmt.Errorf("Invalid value for an integer %q", value)
	}

	return nil
}

// IsUint8 validates whether the string can be converted to an uint8.
func IsUint8(value string) error {
	_, err := strconv.ParseUint(value, 10, 8)
	if err != nil {
		return fmt.Errorf("Invalid value for an integer %q. Must be between 0 and 255", value)
	}

	return nil
}

// IsUint32 validates whether the string can be converted to an uint32.
func IsUint32(value string) error {
	_, err := strconv.ParseUint(value, 10, 32)
	if err != nil {
		return fmt.Errorf("Invalid value for uint32 %q: %v", value, err)
	}

	return nil
}

// IsPriority validates priority number.
func IsPriority(value string) error {
	valueInt, err := strconv.ParseInt(value, 10, 64)
	if err != nil {
		return fmt.Errorf("Invalid value for an integer %q", value)
	}

	if valueInt < 0 || valueInt > 10 {
		return fmt.Errorf("Invalid value for a limit %q. Must be between 0 and 10", value)
	}

	return nil
}

// IsBool validates if string can be understood as a bool.
func IsBool(value string) error {
	if !stringInSlice(strings.ToLower(value), []string{"true", "false", "yes", "no", "1", "0", "on", "off"}) {
		return fmt.Errorf("Invalid value for a boolean %q", value)
	}

	return nil
}

// IsOneOf checks whether the string is present in the supplied slice of strings.
func IsOneOf(value string, valid []string) error {
	if value == "" {
		return nil
	}

	if !stringInSlice(value, valid) {
		return fmt.Errorf("Invalid value %q (not one of %s)", value, valid)
	}

	return nil
}

// IsAny accepts all strings as valid.
func IsAny(value string) error {
	return nil
}

// IsNotEmpty requires a non-empty string.
func IsNotEmpty(value string) error {
	if value == "" {
		return fmt.Errorf("Required value")
	}

	return nil
}

// IsSize checks if string is valid size according to units.ParseByteSizeString.
func IsSize(value string) error {
	_, err := units.ParseByteSizeString(value)
	if err != nil {
		return err
	}

	return nil
}

// IsDeviceID validates string is four lowercase hex characters suitable as Vendor or Device ID.
func IsDeviceID(value string) error {
	regexHexLc, err := regexp.Compile("^[0-9a-f]+$")
	if err != nil {
		return err
	}

	if len(value) != 4 || !regexHexLc.MatchString(value) {
		return fmt.Errorf("Invalid value, must be four lower case hex characters")
	}

	return nil
}

// IsNetworkMAC validates an Ethernet MAC address. e.g. "00:00:5e:00:53:01".
func IsNetworkMAC(value string) error {
	_, err := net.ParseMAC(value)

	// Check is valid Ethernet MAC length and delimiter.
	if err != nil || len(value) != 17 || strings.ContainsAny(value, "-.") {
		return fmt.Errorf("Invalid MAC address, must be 6 bytes of hex separated by colons")
	}

	return nil
}

// IsNetworkAddress validates an IP (v4 or v6) address string. If string is empty, returns valid.
func IsNetworkAddress(value string) error {
	ip := net.ParseIP(value)
	if ip == nil {
		return fmt.Errorf("Not an IP address %q", value)
	}

	return nil
}

// IsNetworkV4 validates an IPv4 CIDR string. If string is empty, returns valid.
func IsNetworkV4(value string) error {
	ip, subnet, err := net.ParseCIDR(value)
	if err != nil {
		return err
	}

	if ip.To4() == nil {
		return fmt.Errorf("Not an IPv4 network %q", value)
	}

	if ip.String() != subnet.IP.String() {
		return fmt.Errorf("Not an IPv4 network address %q", value)
	}

	return nil
}

// IsNetworkAddressV4 validates an IPv4 addresss string. If string is empty, returns valid.
func IsNetworkAddressV4(value string) error {
	ip := net.ParseIP(value)
	if ip == nil || ip.To4() == nil {
		return fmt.Errorf("Not an IPv4 address %q", value)
	}

	return nil
}

// IsNetworkAddressCIDRV4 validates an IPv4 addresss string in CIDR format. If string is empty, returns valid.
func IsNetworkAddressCIDRV4(value string) error {
	ip, subnet, err := net.ParseCIDR(value)
	if err != nil {
		return err
	}

	if ip.To4() == nil {
		return fmt.Errorf("Not an IPv4 address %q", value)
	}

	if ip.String() == subnet.IP.String() {
		return fmt.Errorf("Not a usable IPv4 address %q", value)
	}

	return nil
}

// IsNetworkAddressV4List validates a comma delimited list of IPv4 addresses.
func IsNetworkAddressV4List(value string) error {
	for _, v := range strings.Split(value, ",") {
		v = strings.TrimSpace(v)
		err := IsNetworkAddressV4(v)
		if err != nil {
			return err
		}
	}
	return nil
}

// IsNetworkV4List validates a comma delimited list of IPv4 CIDR strings.
func IsNetworkV4List(value string) error {
	for _, network := range strings.Split(value, ",") {
		network = strings.TrimSpace(network)
		err := IsNetworkV4(network)
		if err != nil {
			return err
		}
	}

	return nil
}

// IsNetworkV6 validates an IPv6 CIDR string. If string is empty, returns valid.
func IsNetworkV6(value string) error {
	ip, subnet, err := net.ParseCIDR(value)
	if err != nil {
		return err
	}

	if ip == nil || ip.To4() != nil {
		return fmt.Errorf("Not an IPv6 network %q", value)
	}

	if ip.String() != subnet.IP.String() {
		return fmt.Errorf("Not an IPv6 network address %q", value)
	}

	return nil
}

// IsNetworkAddressV6 validates an IPv6 addresss string. If string is empty, returns valid.
func IsNetworkAddressV6(value string) error {
	ip := net.ParseIP(value)
	if ip == nil || ip.To4() != nil {
		return fmt.Errorf("Not an IPv6 address %q", value)
	}

	return nil
}

// IsNetworkAddressCIDRV6 validates an IPv6 addresss string in CIDR format. If string is empty, returns valid.
func IsNetworkAddressCIDRV6(value string) error {
	ip, subnet, err := net.ParseCIDR(value)
	if err != nil {
		return err
	}

	if ip.To4() != nil {
		return fmt.Errorf("Not an IPv6 address %q", value)
	}

	if ip.String() == subnet.IP.String() {
		return fmt.Errorf("Not a usable IPv6 address %q", value)
	}

	return nil
}

// IsNetworkAddressV6List validates a comma delimited list of IPv6 addresses.
func IsNetworkAddressV6List(value string) error {
	for _, v := range strings.Split(value, ",") {
		v = strings.TrimSpace(v)
		err := IsNetworkAddressV6(v)
		if err != nil {
			return err
		}
	}
	return nil
}

// IsNetworkV6List validates a comma delimited list of IPv6 CIDR strings.
func IsNetworkV6List(value string) error {
	for _, network := range strings.Split(value, ",") {
		network = strings.TrimSpace(network)
		err := IsNetworkV6(network)
		if err != nil {
			return err
		}
	}

	return nil
}

// IsNetworkRangeV4 validates an IPv4 range in the format "start-end".
func IsNetworkRangeV4(value string) error {
	ips := strings.SplitN(value, "-", 2)
	if len(ips) != 2 {
		return fmt.Errorf("IP range must contain start and end IP addresses")
	}

	for _, ip := range ips {
		err := IsNetworkAddressV4(ip)
		if err != nil {
			return err
		}
	}

	return nil
}

// IsNetworkRangeV4List validates a comma delimited list of IPv4 ranges.
func IsNetworkRangeV4List(value string) error {
	for _, ipRange := range strings.Split(value, ",") {
		err := IsNetworkRangeV4(strings.TrimSpace(ipRange))
		if err != nil {
			return err
		}
	}

	return nil
}

// IsNetworkRangeV6 validates an IPv6 range in the format "start-end".
func IsNetworkRangeV6(value string) error {
	ips := strings.SplitN(value, "-", 2)
	if len(ips) != 2 {
		return fmt.Errorf("IP range must contain start and end IP addresses")
	}

	for _, ip := range ips {
		err := IsNetworkAddressV6(ip)
		if err != nil {
			return err
		}
	}

	return nil
}

// IsNetworkRangeV6List validates a comma delimited list of IPv6 ranges.
func IsNetworkRangeV6List(value string) error {
	for _, ipRange := range strings.Split(value, ",") {
		err := IsNetworkRangeV6(strings.TrimSpace(ipRange))
		if err != nil {
			return err
		}
	}

	return nil
}

// IsNetworkVLAN validates a VLAN ID.
func IsNetworkVLAN(value string) error {
	vlanID, err := strconv.Atoi(value)
	if err != nil {
		return fmt.Errorf("Invalid VLAN ID %q", value)
	}

	if vlanID < 0 || vlanID > 4094 {
		return fmt.Errorf("Out of VLAN ID range (0-4094) %q", value)
	}

	return nil
}

// IsNetworkMTU validates MTU number >= 1280 and <= 9202.
// Anything below 68 and the kernel doesn't allow IPv4, anything below 1280 and the kernel doesn't allow IPv6.
// So require an IPv6-compatible MTU as the low value and cap at the max ethernet jumbo frame size.
func IsNetworkMTU(value string) error {
	mtu, err := strconv.ParseInt(value, 10, 32)
	if err != nil {
		return fmt.Errorf("Invalid MTU %q", value)
	}

	if mtu < 1280 || mtu > 9202 {
		return fmt.Errorf("Out of MTU range (1280-9202) %q", value)
	}

	return nil
}

// IsURLSegmentSafe validates whether value can be used in a URL segment.
func IsURLSegmentSafe(value string) error {
	for _, char := range []string{"/", "?", "&"} {
		if strings.Contains(value, char) {
			return fmt.Errorf("Cannot contain %q", char)
		}
	}

	return nil
}


text:
<?php

/**
 * Pembuatan schema Model
 *
 */
class product_attribute_sub extends Abstract_model {

    public $table           = "";
    public $pkey            = "";
    public $alias           = "";

    public $fields          = array();

    public $selectClause    ="  product_id ,
                                product_attribute_subid ,
                                attribute_ua_name,
                                attribute_bill_name,
                                mandatory_boo,
                                attribute_units,
                                display_position ,
                                val_type,
                                val_refference";

    public $fromClause      = "( select n01 as product_id ,
                                  n02 as product_attribute_subid ,
                                  s01 as attribute_ua_name,
                                  s02 as attribute_bill_name,
                                  s03 as mandatory_boo,
                                  s04 as attribute_units,
                                  n03 as display_position ,
                                  s05 as val_type,
                                  s06 as val_refference
                                  from table(pack_lov.get_prodattr_list_byprodid(%s, to_number(%s), '')) )";

    public $refs            = array();

    function __construct($product_id = 0) {
        parent::__construct();
        //$this->db = $this->load->database('tosdb', TRUE);
        //$this->db->_escape_char = ' ';
        $this->fromClause = sprintf($this->fromClause, "'".$this->session->userdata('user_name')."'", "'".$product_id."'");
        // $this->db_crm = $this->load->database('default', TRUE);
        // $this->db_crm->_escape_char = ' ';
    }

    function validate() {
        $ci =& get_instance();

        if($this->actionType == 'CREATE') {
            //do something
            // example :
            //$this->record['created_date'] = date('Y-m-d');
            //$this->record['updated_date'] = date('Y-m-d');

        }else {
            //do something
            //example:
            //$this->record['updated_date'] = date('Y-m-d');
            //if false please throw new Exception

        }
        return true;
    }

}

/* End of file Users.php */


text:
PointRenderer::PointRenderer() : SceneObjectRenderer(PointRenderer::GetShaderList())
{
}

PointRenderer::~PointRenderer()
{
}

std::vector<Shader> PointRenderer::GetShaderList()
{
   std::vector<Shader> shader_list;
   shader_list.push_back(Shader(point_object_VS_vert, GL_VERTEX_SHADER, "point_object_VS"));
   shader_list.push_back(Shader(point_object_FS_frag, GL_FRAGMENT_SHADER, "point_object_FS"));
   return shader_list;
}

void PointRenderer::SetModelToClipMatrixPA(const glm::mat4& model_to_clip_matrix)
{
   GLuint model_to_clip_uniform = program_.GetUniform("modelToClipMatrix");
   glUniformMatrix4fv(model_to_clip_uniform, 1, GL_FALSE, glm::value_ptr(model_to_clip_matrix));
}

void PointRenderer::AttachPointAdapter(PointAdapter* point_adapter)
{
   int priority = point_adapter->GetPriority();
   point_adapters_[priority].push_back(point_adapter);
}

void PointRenderer::DetachPointAdapter(PointAdapter* point_adapter)
{
   int priority = point_adapter->GetPriority();
   for (auto it = point_adapters_[priority].begin(); it != point_adapters_[priority].end(); it++)
   {
      if ((*it)->GetKey() == point_adapter->GetKey())
      {
         point_adapters_[priority].erase(it);
         break;
      }
   }
}

void PointRenderer::Reset()
{
   point_adapters_[0].clear();
   point_adapters_[1].clear();
   point_adapters_[2].clear();
}

void PointRenderer::Render(const glm::mat4& view, const glm::mat4& projection, int priority)
{
   if (point_adapters_[priority].size() == 0)
   {
      return;
   }

   ActivateProgram();
   glm::mat4 world_to_clip = projection * view;
   for (auto point_adapter : point_adapters_[priority])
   {
      SetModelToClipMatrixPA(world_to_clip * point_adapter->GetModelMatrix());
      point_adapter->Render();
   }
   DeactivateProgram();
}


text:
<?xml version="1.0" encoding="utf-8"?>
<manifest package="com.frankzhu.filtermenu" />


text:
(function() {

  'use strict';

  function fcCanvas(flowchartConstants, FlowchartCanvasService) {
    return {
      restrict: 'E',
      templateUrl: "flowchart/canvas.html",
      replace: true,
      scope: {
        model: "=",
        selectedObjects: "=",
        edgeStyle: '@',
        userCallbacks: '=?callbacks',
        automaticResize: '=?',
        dragAnimation: '=?',
        nodeWidth: '=?',
        nodeHeight: '=?'
      },
      controller: 'canvasController',
      link: function(scope, element) {
        function adjustCanvasSize() {
          if (scope.model) {
            var maxX = 0;
            var maxY = 0;
            angular.forEach(scope.model.nodes, function (node, key) {
              maxX = Math.max(node.x + scope.nodeWidth, maxX);
              maxY = Math.max(node.y + scope.nodeHeight, maxY);
            });
            element.css('width', Math.max(maxX, element.prop('offsetWidth')) + 'px');
            element.css('height', Math.max(maxY, element.prop('offsetHeight')) + 'px');
          }
        }
        if (scope.edgeStyle !== flowchartConstants.curvedStyle && scope.edgeStyle !== flowchartConstants.lineStyle) {
          throw new Error('edgeStyle not supported.');
        }
        scope.nodeHeight = scope.nodeHeight || 200;
        scope.nodeWidth = scope.nodeWidth || 200;
        scope.dragAnimation = scope.dragAnimation || 'repaint';

        scope.flowchartConstants = flowchartConstants;
        element.addClass(flowchartConstants.canvasClass);
        element.on('dragover', scope.dragover);
        element.on('drop', scope.drop);

        scope.$watch('model', adjustCanvasSize);

        FlowchartCanvasService.setCanvasHtmlElement(element[0]);
        scope.modelservice.setCanvasHtmlElement(element[0]);
        scope.modelservice.setSvgHtmlElement(element[0].querySelector('svg'));
      }
    };
  }

  angular
    .module('flowchart')
    .directive('fcCanvas', fcCanvas);

}());


text:
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using DotSpatial.Data;
using DotSpatial.Symbology;

namespace DotSpatial.Controls
{
    /// <summary>
    /// This is a specialized FeatureLayer that specifically handles drawing tiled images.
    /// </summary>
    public class MapTiledImageLayer : TiledImageLayer
    {
        #region  Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="MapTiledImageLayer"/> class.
        /// </summary>
        /// <param name="baseImage">The image that is the base of this layer.</param>
        public MapTiledImageLayer(ITiledImage baseImage)
            : base(baseImage)
        {
            Configure(baseImage);
        }

        #endregion

        #region Methods

        /// <summary>
        /// This will draw any features that intersect this region. To specify the features
        /// directly, use OnDrawFeatures. This will not clear existing buffer content.
        /// For that call Initialize instead.
        /// </summary>
        /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space.</param>
        /// <param name="regions">The geographic regions to draw.</param>
        public void DrawRegions(MapArgs args, List<Extent> regions)
        {
            List<Rectangle> clipRects = args.ProjToPixel(regions);
            DrawWindows(args, regions, clipRects);
        }

        private void Configure(ITiledImage baseImage)
        {
            IsVisible = true;
            LegendText = Path.GetFileName(baseImage.Filename);
            OnFinishedLoading();
        }

        /// <summary>
        /// This draws to the back buffer. If the back buffer doesn't exist, this will create one.
        /// This will not flip the back buffer to the front.
        /// </summary>
        /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space.</param>
        /// <param name="regions">The geographic regions to draw.</param>
        /// <param name="clipRectangles">The clip rectangles.</param>
        private void DrawWindows(MapArgs args, IList<Extent> regions, IList<Rectangle> clipRectangles)
        {
            Graphics g = args.Device;
            int numBounds = Math.Min(regions.Count, clipRectangles.Count);

            for (int i = 0; i < numBounds; i++)
            {
                Bitmap bmp = DataSet.GetBitmap(regions[i], clipRectangles[i].Size);
                if (bmp != null) g.DrawImage(bmp, clipRectangles[i]);
            }

            if (args.Device == null) g.Dispose();
        }

        #endregion
    }
}


text:
# ----------------------------------------------------------------------------------
#
# Copyright Microsoft Corporation
# 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.
# ----------------------------------------------------------------------------------

<#
.SYNOPSIS
Test List Resource Skus
#>
function Test-GetResourceSku
{
	$skulist = Get-AzureRmComputeResourceSku | where {$_.Locations -eq "eastus"};
	Assert-True { $skulist.Count -gt 0; }
	$output = $skulist | Out-String;
	Assert-True { $output.Contains("availabilitySets"); }
	Assert-True { $output.Contains("virtualMachines"); }
	Assert-True { $output.Contains("Zones"); }
}


text:
Automates Android zero-touch enrollment for device resellers, customers, and EMMs.

This page contains information about getting started with the Android Device Provisioning Partner API
using the Google API Client Library for Java. In addition, you may be interested
in the following documentation:

* Browse the [Javadoc reference for the Android Device Provisioning Partner API][javadoc]
* Read the [Developer's Guide for the Google API Client Library for Java][google-api-client].
* Interact with this API in your browser using the [APIs Explorer for the Android Device Provisioning Partner API][api-explorer]

## Installation

### Maven

Add the following lines to your `pom.xml` file:

```xml
<project>
  <dependencies>
    <dependency>
      <groupId>com.google.apis</groupId>
      <artifactId>google-api-services-androiddeviceprovisioning</artifactId>
      <version>v1-rev20200801-1.30.10</version>
    </dependency>
  </dependencies>
</project>
```

### Gradle

```gradle
repositories {
  mavenCentral()
}
dependencies {
  compile 'com.google.apis:google-api-services-androiddeviceprovisioning:v1-rev20200801-1.30.10'
}
```

[javadoc]: https://googleapis.dev/java/google-api-services-androiddeviceprovisioning/latest/index.html
[google-api-client]: https://github.com/googleapis/google-api-java-client/
[api-explorer]: https://developers.google.com/apis-explorer/#p/androiddeviceprovisioning/v1/


text:
GMTSXQ11 ; SLC/JER - XQORM5 for Export w/Health Summary ;1/10/92  15:07
 ;;2.5;Health Summary;;Dec 16, 1992
XQORM5 ; SLC/KCM - Menu Help ;10/10/89  14:02 ;
 ;;6.52;Copyright 1990, DVA;
HELP1 ;From: XQORM4
 I $D(XQORM("?"))'[0 X XQORM("?") Q:X="?"
 W ! F J=1:1 S ORUSV=$T(HTX1+J) Q:ORUSV["ZZZZ"  W !,$P(ORUSV,";",3,99)
 W ! ;I $D(XQORM("?"))'[0 X XQORM("?")
 Q
HELP2 ;From: XQORM4
 F J=1:1 S ORUSV=$T(HTX2+J) Q:ORUSV["ZZZZ"  W !,$P(ORUSV,";",3,99)
 Q
HELP3 ;From: XQORM3
 W !!,"Enter a number or type another selection",!
 Q
HTX1 ;;Help Text for "?"
 ;;Enter selection(s) by typing the name(s), number(s), or abbreviation(s).
 ;;ZZZZ
HTX2 ;;Help Text for "??"
 ;;ALL items may be selected by typing "ALL".
 ;;
 ;;RANGES of items (if numbered) may be selected using the dash.
 ;;  For example, "2-5" selects the items numbered 2,3,4,5.
 ;;
 ;;EXCEPTIONS may be entered by preceding them with an minus.
 ;;  For example, "2-5,-4" selects the items numbered 2,3,5.
 ;;           or, "ALL,-THAT" selects all items except "THAT".
 ;;
 ;;PRE-SELECTION of items may be done by separating them with ";".
 ;;  For example, "ADD;LAB;WARD;GEN;GLUCOSE" will advance through the
 ;;  5 menus, automatically selecting the items.
 ;;
 ;;JUMP AND RETURN may be done by typing "^^item".
 ;;  For example, "^^GLUCOSE" jumps directly to the prompts for ordering
 ;;  a glucose and then returns to the menu where you typed "^^GLUCOSE".
 ;;ZZZZ


text:
require 'shoes'
require "Qt"
require 'shoes/qt/app'
require 'shoes/qt/flow_layout'
require 'shoes/qt/slot'
require 'shoes/qt/animation'
require 'shoes/qt/button'

module Shoes
  module Qt
    def self.init
      @app ||= ::Qt::Application.new []
    end

    def self.start
      @app.exec
    end
  end
end


text:
<?xml version="1.0" encoding="utf-8"?>
<library>
	<extension id="blackberry.app.event">
		<entryClass>blackberry.applicationEvents.ApplicationEvent</entryClass>
	</extension>

	<platforms>
		<platform value="AIR">
			<target version="default" config="AIR_XHR" />
		</platform>
	</platforms>

	<configurations>
		<configuration name="AIR_XHR" version="1.0" comment="For XHR architecture for Java implementation">
			<src type="text/javascript" path="js/common/app_event_dispatcher.js" comment="Application JS XHR dispatcher" />
			<src type="text/javascript" path="js/common/app_event_ns.js" comment="Application JS interface" />
			<src type="text/actionscript" path="src/Air/ApplicationEvents/src" comment="ActionScript implementation" />
		</configuration>
	</configurations>

	<features>
		<feature id="blackberry.app.event" version="1.0.0" />
	</features>
</library>


text:
'use strict';

var _ = require('lodash');

function Claim(desc) {
  _.extend(this, desc);
}
var Claims = {
  create: function create(desc) {
    var claim = new Claim(desc);
    Claims[claim.key] = claim;
    return claim;
  }
};

module.exports = Claims;
//# sourceMappingURL=claims.js.map


text:
namespace Marklight
{
    /// <summary>
    /// Specifies the arrangment of color components on a hexidecimal color value.
    /// </summary>
    public enum HexColorType
    {
        /// <summary>
        /// Color components are arranged alpha, red, green, blue.
        /// </summary>
        ARGB,
        /// <summary>
        /// Color components are arranged red, green, blue, alpha.
        /// </summary>
        RGBA
    }
}


text:
import { Component, OnInit } from '@angular/core';
import { AdminService } from '../admin.service';
import { NotificationsService } from '../../../../node_modules/angular2-notifications';

@Component({
  selector: 'app-manage-deleted-facts',
  templateUrl: './manage-deleted-facts.component.html',
  styleUrls: ['./manage-deleted-facts.component.css']
})
export class ManageDeletedFactsComponent implements OnInit {

  public deletedFacts: any;
  public notificationOptions: Object;

  constructor(
    private _adminService: AdminService,
    private _notification: NotificationsService
  ) { }

  ngOnInit() {
    this._adminService.getDeletedFacts()
      .subscribe((res: any) => {
        this.deletedFacts = res.body.data
      });

    this.notificationOptions = { timeOut: 2500, pauseOnHover: true, showProgressBar: false, animate: 'scale', position: ['right', 'top'] };
  }

  restoreImage(factId) {
    this._adminService.restoreDeletedFact(factId)
      .subscribe((res: any) => {
        this._notification.success('success', 'The fact was restored')
        this.deletedFacts.forEach((fact) => {
          if (fact._id === factId) {
            fact.isDeleted = false;
            return;
          };
        });
      },
      (err: any) => {
        this._notification.error('success', err)
      });
  }

}


text:
<?xml version="1.0"?>
<!DOCTYPE module PUBLIC
        "-//Puppy Crawl//DTD Check Configuration 1.3//EN"
        "http://www.puppycrawl.com/dtds/configuration_1_3.dtd">

<module name = "Checker">
    <property name="charset" value="UTF-8"/>
    <property name="fileExtensions" value="java"/>
    <module name="FileTabCharacter">
        <property name="eachLine" value="true"/>
    </module>
    <module name="Header">
        <property name="headerFile" value="${basedir}/src/main/resources/HEADER"/>
        <property name="ignoreLines" value="3, 7"/>
        <property name="fileExtensions" value="java"/>
    </module>
    <module name="SuppressWarningsFilter" />
    <module name="NewlineAtEndOfFile"/>
    <module name="TreeWalker">
        <module name="SuppressWarningsHolder" />
        <module name="AnnotationUseStyle"/>
        <module name="AnnotationLocation">
            <property name="tokens" value="CLASS_DEF, INTERFACE_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF"/>
        </module>
        <module name="AnnotationLocation">
            <property name="tokens" value="VARIABLE_DEF"/>
            <property name="allowSamelineMultipleAnnotations" value="true"/>
        </module>
        <module name="MissingDeprecated"/>
        <module name="MissingOverride"/>
        <module name="PackageAnnotation"/>
        <module name="AvoidNestedBlocks"/>
        <module name="EmptyBlock"/>
        <module name="EmptyCatchBlock">
            <property name="commentFormat" value="This is expected"/>
            <property name="exceptionVariableName" value="expected|ignore"/>
        </module>
        <module name="LeftCurly"/>
        <module name="NeedBraces">
            <property name="allowSingleLineStatement" value="true"/>
        </module>
        <module name="RightCurly"/>
        <module name="RightCurly">
            <property name="option" value="alone"/>
            <property name="tokens" value="CLASS_DEF, METHOD_DEF, CTOR_DEF, LITERAL_FOR, LITERAL_WHILE, LITERAL_DO, STATIC_INIT, INSTANCE_INIT"/>
        </module>
        <module name="FinalClass"/>
        <module name="HideUtilityClassConstructor"/>
        <module name="InnerTypeLast"/>
        <module name="InterfaceIsType"/>
        <module name="MutableException"/>
        <module name="OneTopLevelClass"/>
        <module name="ThrowsCount">
            <property name="max" value="3"/>
        </module>
        <module name="VisibilityModifier">
            <property name="protectedAllowed" value="true"/>
        </module>
        <module name="CovariantEquals"/>
        <module name="DeclarationOrder"/>
        <module name="DefaultComesLast"/>
        <module name="EmptyStatement"/>
        <module name="EqualsAvoidNull"/>
        <module name="EqualsHashCode"/>
        <module name="ExplicitInitialization"/>
        <module name="FallThrough"/>
        <module name="FinalLocalVariable">
            <property name="tokens" value="VARIABLE_DEF"/>
            <property name="validateEnhancedForLoopVariable" value="true"/>
        </module>
        <module name="HiddenField">
            <property name="ignoreConstructorParameter" value="true"/>
            <property name="ignoreSetter" value="true"/>
            <property name="setterCanReturnItsClass" value="true"/>
        </module>
        <module name="IllegalThrows"/>
        <module name="IllegalToken"/>
        <module name="IllegalTokenText">
            <property name="tokens" value="STRING_LITERAL, CHAR_LITERAL"/>
            <property name="format" value="\\u00(08|09|0(a|A)|0(c|C)|0(d|D)|22|27|5(C|c))|\\(0(10|11|12|14|15|42|47)|134)"/>
            <property name="message" value="Avoid using corresponding octal or Unicode escape."/>
        </module>
        <module name="IllegalType"/>
        <module name="InnerAssignment"/>
        <module name="MagicNumber"/>
        <module name="MissingSwitchDefault"/>
        <module name="ModifiedControlVariable"/>
        <module name="MultipleVariableDeclarations"/>
        <module name="NestedIfDepth"/>
        <module name="NestedTryDepth"/>
        <module name="NoClone"/>
        <module name="NoFinalizer"/>
        <module name="OneStatementPerLine"/>
        <module name="OverloadMethodsDeclarationOrder"/>
        <module name="PackageDeclaration"/>
        <module name="ParameterAssignment"/>
        <module name="RequireThis"/>
        <module name="SimplifyBooleanExpression"/>
        <module name="SimplifyBooleanReturn"/>
        <module name="StringLiteralEquality"/>
        <module name="SuperClone"/>
        <module name="SuperFinalize"/>
        <module name="UnnecessaryParentheses"/>
        <module name="VariableDeclarationUsageDistance"/>
        <module name="AvoidStaticImport">
            <property name="excludes" value="java.lang.System.out,java.lang.Math.*"/>
        </module>
        <module name="CustomImportOrder">
            <property name="specialImportsRegExp" value="gg.uhc"/>
            <property name="sortImportsInGroupAlphabetically" value="true"/>
            <property name="customImportOrderRules" value="STATIC###SPECIAL_IMPORTS###THIRD_PARTY_PACKAGE###STANDARD_JAVA_PACKAGE"/>
        </module>
        <module name="IllegalImport">
            <property name="illegalPkgs" value="net.minecraft, org.craftbukkit, sun"/>
        </module>
        <module name="RedundantImport"/>
        <module name="UnusedImports"/>
        <module name="AtclauseOrder">
            <property name="tagOrder" value="@param, @return, @throws, @deprecated"/>
            <property name="target" value="CLASS_DEF, INTERFACE_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF, VARIABLE_DEF"/>
        </module>
        <module name="JavadocMethod">
            <property name="scope" value="public"/>
            <property name="allowMissingJavadoc" value="true"/>
            <property name="allowedAnnotations" value="Override, Test"/>
            <property name="allowThrowsTagsForSubclasses" value="true"/>
        </module>
        <module name="JavadocParagraph"/>
        <module name="SingleLineJavadoc">
            <property name="ignoreInlineTags" value="false"/>
        </module>
        <module name="NonEmptyAtclauseDescription"/>
        <module name="JavadocTagContinuationIndentation"/>
        <module name="SummaryJavadoc">
            <property name="forbiddenSummaryFragments" value="^@return the *|^This method returns |^A [{]@code [a-zA-Z0-9]+[}]( is a )"/>
        </module>
        <module name="BooleanExpressionComplexity"/>
        <module name="ClassDataAbstractionCoupling"/>
        <module name="ClassFanOutComplexity"/>
        <!--<module name="CyclomaticComplexity">-->
            <!--<property name="max" value="15"/>-->
        <!--</module>-->
        <module name="JavaNCSS"/>
        <!--<module name="NPathComplexity"/>-->
        <module name="ArrayTypeStyle"/>
        <module name="AvoidEscapedUnicodeCharacters">
            <property name="allowEscapesForControlCharacters" value="true"/>
            <property name="allowByTailComment" value="true"/>
            <property name="allowNonPrintableEscapes" value="true"/>
        </module>
        <module name="CommentsIndentation"/>
        <module name="Indentation"/>
        <module name="OuterTypeFilename"/>
        <module name="TodoComment">
            <property name="format" value="(TODO)|(FIXME)"/>
        </module>
        <module name="UpperEll"/>
        <module name="ModifierOrder"/>
        <module name="RedundantModifier"/>
        <module name="AbbreviationAsWordInName">
            <property name="ignoreFinal" value="false"/>
            <property name="allowedAbbreviationLength" value="1"/>
            <property name="allowedAbbreviations" value="XZ,XYZ,UUID,UHC,XP,NBT,PVP,PM"/>
        </module>
        <module name="CatchParameterName">
            <property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9]*$"/>
            <message key="name.invalidPattern" value="Catch parameter name ''{0}'' must match pattern ''{1}''."/>
        </module>
        <module name="ClassTypeParameterName">
            <property name="format" value="(^[A-Z][0-9]?)$|([A-Z][a-zA-Z0-9]*[T]$)"/>
            <message key="name.invalidPattern" value="Class type name ''{0}'' must match pattern ''{1}''."/>
        </module>
        <module name="ConstantName"/>
        <module name="InterfaceTypeParameterName">
            <property name="format" value="(^[A-Z][0-9]?)$|([A-Z][a-zA-Z0-9]*[T]$)"/>
            <message key="name.invalidPattern" value="Interface type name ''{0}'' must match pattern ''{1}''."/>
        </module>
        <module name="LocalFinalVariableName"/>
        <module name="LocalVariableName">
            <property name="tokens" value="VARIABLE_DEF"/>
            <property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9]*$"/>
            <property name="allowOneCharVarInForLoop" value="true"/>
            <message key="name.invalidPattern" value="Local variable name ''{0}'' must match pattern ''{1}''."/>
        </module>
        <module name="MemberName">
            <property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9]*$"/>
            <message key="name.invalidPattern" value="Member name ''{0}'' must match pattern ''{1}''."/>
        </module>
        <module name="MethodName">
            <property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9_]*$"/>
            <message key="name.invalidPattern" value="Method name ''{0}'' must match pattern ''{1}''."/>
        </module>
        <module name="MethodTypeParameterName">
            <property name="format" value="(^[A-Z][0-9]?)$|([A-Z][a-zA-Z0-9]*[T]$)"/>
            <message key="name.invalidPattern" value="Method type name ''{0}'' must match pattern ''{1}''."/>
        </module>
        <module name="PackageName">
            <property name="format" value="^[a-z]+(\.[a-z][a-z0-9]*)*$"/>
            <message key="name.invalidPattern" value="Package name ''{0}'' must match pattern ''{1}''."/>
        </module>
        <module name="ParameterName">
            <property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9]*$"/>
            <message key="name.invalidPattern" value="Parameter name ''{0}'' must match pattern ''{1}''."/>
        </module>
        <module name="TypeName"/>
        <module name="AnonInnerLength"/>
        <module name="LineLength">
            <property name="max" value="120"/>
            <property name="ignorePattern" value="^package.*|^import.*|a href|href|http://|https://|ftp://"/>
        </module>
        <module name="OuterTypeNumber"/>
        <module name="ParameterNumber"/>
        <module name="EmptyForInitializerPad"/>
        <module name="EmptyLineSeparator">
            <property name="allowNoEmptyLineBetweenFields" value="true"/>
        </module>
        <module name="GenericWhitespace"/>
        <module name="MethodParamPad"/>
        <module name="NoLineWrap"/>
        <module name="OperatorWrap">
            <property name="tokens" value="BAND, BOR, BSR, BXOR, DIV, EQUAL, GE, GT, LAND, LE, LITERAL_INSTANCEOF, LOR, LT, MINUS, MOD, NOT_EQUAL, PLUS, QUESTION, SL, SR, STAR "/>
        </module>
        <module name="ParenPad"/>
        <module name="SeparatorWrap">
            <property name="tokens" value="DOT"/>
            <property name="option" value="NL"/>
        </module>
        <module name="SeparatorWrap">
            <property name="tokens" value="COMMA"/>
            <property name="option" value="EOL"/>
        </module>
        <module name="WhitespaceAfter"/>
        <module name="WhitespaceAround">
            <property name="allowEmptyConstructors" value="true"/>
            <property name="allowEmptyMethods" value="true"/>
            <property name="allowEmptyTypes" value="true"/>
            <property name="allowEmptyLoops" value="true"/>
        </module>
    </module>
</module>


text:
package com.nirima.snowglobe.web.json;

import com.fasterxml.jackson.databind.ObjectMapper;

import javax.inject.Singleton;
import javax.ws.rs.Produces;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;

@Provider
@Singleton
@Produces
public class JacksonOMP implements ContextResolver<ObjectMapper> {

  public JacksonOMP() {
    System.out.println("OMP");
  }

  @Override
  public ObjectMapper getContext(Class<?> aClass) {
    final ObjectMapper mapper = new ObjectMapper();
   // Hibernate4Module hbm = new Hibernate4ModuleExtra();
   // hbm.configure(Hibernate4Module.Feature.SERIALIZE_IDENTIFIER_FOR_LAZY_NOT_LOADED_OBJECTS, true);

   //mapper.registerModule(hbm);
    return mapper;
  }
}