text:
/*--------------------------------------------------*/

#import "NSDictionary+GLBNS.h"
#import "NSArray+GLBNS.h"
#import "NSString+GLBNS.h"

/*--------------------------------------------------*/

#import "UIColor+GLBUI.h"

/*--------------------------------------------------*/

@interface GLBModelPack : NSObject

+ (nonnull instancetype)pack NS_SWIFT_UNAVAILABLE("Use init()");

- (nullable id)pack:(nullable id)packValue;
- (nullable id)unpack:(nullable id)packValue;

@end

/*--------------------------------------------------*/

@interface GLBModelPackSet : GLBModelPack

@property(nonatomic, nonnull, readonly, strong) GLBModelPack* converter;

+ (nonnull instancetype)pack NS_UNAVAILABLE;
+ (nonnull instancetype)packWithModel:(nonnull Class)model NS_SWIFT_UNAVAILABLE("Use init(model:)");
+ (nonnull instancetype)packWithConverter:(nonnull GLBModelPack*)converter NS_SWIFT_UNAVAILABLE("Use init(converter:)");

- (nonnull instancetype)init NS_UNAVAILABLE;
- (nonnull instancetype)initWithModel:(nonnull Class)model;
- (nonnull instancetype)initWithConverter:(nonnull GLBModelPack*)converter NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@interface GLBModelPackOrderedSet : GLBModelPack

@property(nonatomic, nonnull, readonly, strong) GLBModelPack* converter;

+ (nonnull instancetype)pack NS_UNAVAILABLE;
+ (nonnull instancetype)packWithModel:(nonnull Class)model NS_SWIFT_UNAVAILABLE("Use init(model:)");
+ (nonnull instancetype)packWithConverter:(nonnull GLBModelPack*)converter NS_SWIFT_UNAVAILABLE("Use init(converter:)");

- (nonnull instancetype)init NS_UNAVAILABLE;
- (nonnull instancetype)initWithModel:(nonnull Class)model;
- (nonnull instancetype)initWithConverter:(nonnull GLBModelPack*)converter NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@interface GLBModelPackArray : GLBModelPack

@property(nonatomic, nonnull, readonly, strong) GLBModelPack* converter;

+ (nonnull instancetype)pack NS_UNAVAILABLE;
+ (nonnull instancetype)packWithModel:(nonnull Class)model NS_SWIFT_UNAVAILABLE("Use init(model:)");
+ (nonnull instancetype)packWithConverter:(nonnull GLBModelPack*)converter NS_SWIFT_UNAVAILABLE("Use init(converter:)");

- (nonnull instancetype)init NS_UNAVAILABLE;
- (nonnull instancetype)initWithModel:(nonnull Class)model;
- (nonnull instancetype)initWithConverter:(nonnull GLBModelPack*)converter NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@interface GLBModelPackDictionary : GLBModelPack

@property(nonatomic, nonnull, readonly, strong) GLBModelPack* keyConverter;
@property(nonatomic, nonnull, readonly, strong) GLBModelPack* valueConverter;

+ (nonnull instancetype)pack NS_UNAVAILABLE;
+ (nonnull instancetype)packWithKeyModel:(nonnull Class)keyModel valueModel:(nonnull Class)valueModel NS_SWIFT_UNAVAILABLE("Use init(keyModel:valueModel:)");
+ (nonnull instancetype)packWithKeyConverter:(nonnull GLBModelPack*)keyConverter valueConverter:(nonnull GLBModelPack*)valueConverter NS_SWIFT_UNAVAILABLE("Use init(keyConverter:valueConverter:)");

- (nonnull instancetype)init NS_UNAVAILABLE;
- (nonnull instancetype)initWithKeyModel:(nonnull Class)keyModel valueModel:(nonnull Class)valueModel;
- (nonnull instancetype)initWithKeyConverter:(nonnull GLBModelPack*)keyConverter valueConverter:(nonnull GLBModelPack*)valueConverter NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@interface GLBModelPackBool : GLBModelPack

@property(nonatomic, readonly) BOOL defaultValue;

+ (nonnull instancetype)packWithDefaultValue:(BOOL)defaultValue NS_SWIFT_UNAVAILABLE("Use init(defaultValue:)");

- (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
- (nonnull instancetype)initWithDefaultValue:(BOOL)defaultValue NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@interface GLBModelPackString : GLBModelPack

@property(nonatomic, nullable, readonly, strong) NSString* defaultValue;

+ (nonnull instancetype)packWithDefaultValue:(nonnull NSString*)defaultValue NS_SWIFT_UNAVAILABLE("Use init(defaultValue:)");

- (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
- (nonnull instancetype)initWithDefaultValue:(nonnull NSString*)defaultValue NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@interface GLBModelPackUrl : GLBModelPack

@property(nonatomic, nullable, readonly, strong) NSURL* defaultValue;

+ (nonnull instancetype)packWithDefaultValue:(nonnull NSURL*)defaultValue NS_SWIFT_UNAVAILABLE("Use init(defaultValue:)");

- (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
- (nonnull instancetype)initWithDefaultValue:(nonnull NSURL*)defaultValue NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@interface GLBModelPackNumber : GLBModelPack

@property(nonatomic, nullable, readonly, strong) NSNumber* defaultValue;

+ (nonnull instancetype)packWithDefaultValue:(nonnull NSNumber*)defaultValue NS_SWIFT_UNAVAILABLE("Use init(defaultValue:)");

- (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
- (nonnull instancetype)initWithDefaultValue:(nonnull NSNumber*)defaultValue NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@interface GLBModelPackDate : GLBModelPack

@property(nonatomic, nullable, readonly, strong) NSDate* defaultValue;

+ (nonnull instancetype)packWithDefaultValue:(nonnull NSDate*)defaultValue NS_SWIFT_UNAVAILABLE("Use init(defaultValue:)");

- (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
- (nonnull instancetype)initWithDefaultValue:(nonnull NSDate*)defaultValue NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@class CLLocation;

/*--------------------------------------------------*/

@interface GLBModelPackLocation : GLBModelPack

@property(nonatomic, nullable, readonly, strong) CLLocation* defaultValue;

+ (nonnull instancetype)packWithDefaultValue:(nonnull CLLocation*)defaultValue NS_SWIFT_UNAVAILABLE("Use init(defaultValue:)");

- (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
- (nonnull instancetype)initWithDefaultValue:(nonnull CLLocation*)defaultValue NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@class UIColor;

/*--------------------------------------------------*/

@interface GLBModelPackColor : GLBModelPack

@property(nonatomic, nullable, readonly, strong) UIColor* defaultValue;

+ (nonnull instancetype)packWithDefaultValue:(nonnull UIColor*)defaultValue NS_SWIFT_UNAVAILABLE("Use init(defaultValue:)");

- (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
- (nonnull instancetype)initWithDefaultValue:(nonnull UIColor*)defaultValue NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/

@interface GLBModelPackModel : GLBModelPack

@property(nonatomic, nullable, readonly) Class model;

+ (nonnull instancetype)pack NS_UNAVAILABLE;
+ (nonnull instancetype)packWithModel:(nonnull Class)model NS_SWIFT_UNAVAILABLE("Use init(model:)");

- (nonnull instancetype)init NS_UNAVAILABLE;
- (nonnull instancetype)initWithModel:(nonnull Class)model NS_DESIGNATED_INITIALIZER;

@end

/*--------------------------------------------------*/


text:
<?xml version="1.0"?>
<!--Phoronix Test Suite v3.0.0a3 (Iveland) [ http://www.phoronix-test-suite.com/ ]-->
<PhoronixTestSuite>
  <TestInformation>
    <Title>Threaded I/O Tester</Title>
    <AppVersion>0.3.3</AppVersion>
    <Description>Tiotester (Threaded I/O Tester) benchmarks the hard disk drive / file-system performance.</Description>
    <ResultScale>MB/s</ResultScale>
    <Proportion>HIB</Proportion>
    <TimesToRun>4</TimesToRun>
  </TestInformation>
  <TestProfile>
    <Version>1.1.0</Version>
    <SupportedPlatforms>Linux, Solaris, MacOSX, BSD</SupportedPlatforms>
    <SoftwareType>Utility</SoftwareType>
    <TestType>Disk</TestType>
    <License>Free</License>
    <Status>Verified</Status>
    <ExternalDependencies>build-utilities</ExternalDependencies>
    <EnvironmentSize>0.2</EnvironmentSize>
    <ProjectURL>http://sourceforge.net/projects/tiobench/</ProjectURL>
    <Maintainer>Michael Larabel</Maintainer>
  </TestProfile>
  <TestSettings>
    <Option>
      <DisplayName>Test</DisplayName>
      <Identifier>test-item</Identifier>
      <Menu>
        <Entry>
          <Name>Write</Name>
          <Value>-k3 -k2 -k1</Value>
        </Entry>
        <Entry>
          <Name>Random Write</Name>
          <Value>-k3 -k2</Value>
        </Entry>
        <Entry>
          <Name>Read</Name>
          <Value>-k3 -k1</Value>
        </Entry>
        <Entry>
          <Name>Random Read</Name>
          <Value>-k2 -k1</Value>
        </Entry>
      </Menu>
    </Option>
    <Option>
      <DisplayName>Size Per Thread</DisplayName>
      <Identifier>filesize-per-thread</Identifier>
      <ArgumentPrefix>-f </ArgumentPrefix>
      <Menu>
        <Entry>
          <Name>32MB</Name>
          <Value>32</Value>
        </Entry>
        <Entry>
          <Name>64MB</Name>
          <Value>64</Value>
        </Entry>
        <Entry>
          <Name>128MB</Name>
          <Value>128</Value>
        </Entry>
        <Entry>
          <Name>256MB</Name>
          <Value>256</Value>
        </Entry>
      </Menu>
    </Option>
    <Option>
      <DisplayName>Thread Count</DisplayName>
      <Identifier>thread-count</Identifier>
      <ArgumentPrefix>-t </ArgumentPrefix>
      <Menu>
        <Entry>
          <Name>4</Name>
          <Value>4</Value>
        </Entry>
        <Entry>
          <Name>8</Name>
          <Value>8</Value>
        </Entry>
        <Entry>
          <Name>16</Name>
          <Value>16</Value>
        </Entry>
        <Entry>
          <Name>32</Name>
          <Value>32</Value>
        </Entry>
      </Menu>
    </Option>
  </TestSettings>
</PhoronixTestSuite>

redpajama_set_name: RedPajamaGithub


text:
package io.appium.java_client.ios.internal;

import io.appium.java_client.AppiumDriver;
import io.appium.java_client.MobileElement;
import io.appium.java_client.internal.JsonToMobileElementConverter;
import io.appium.java_client.ios.IOSElement;

public class JsonToIOSElementConverter extends JsonToMobileElementConverter {

	public JsonToIOSElementConverter(AppiumDriver<?> driver) {
		super(driver);
	}

	@Override
	protected MobileElement newMobileElement() {
		IOSElement toReturn = new IOSElement();
		toReturn.setParent(driver);
		return toReturn;
	}

}


text:
class WebContentsModalDialog;

namespace content {
class BrowserContext;
class RenderViewHost;
class WebContents;
}

namespace ui {
class WebDialogDelegate;
class WebDialogWebContentsDelegate;
}

class ConstrainedWebDialogDelegate {
 public:
  virtual const ui::WebDialogDelegate* GetWebDialogDelegate() const = 0;
  virtual ui::WebDialogDelegate* GetWebDialogDelegate() = 0;

  // Called when the dialog is being closed in response to a "DialogClose"
  // message from WebUI.
  virtual void OnDialogCloseFromWebUI() = 0;

  // If called, on dialog closure, the dialog will release its WebContents
  // instead of destroying it. After which point, the caller will own the
  // released WebContents.
  virtual void ReleaseWebContentsOnDialogClose() = 0;

  // Returns the WebContentsModalDialog.
  virtual WebContentsModalDialog* GetWindow() = 0;

  // Returns the WebContents owned by the constrained window.
  virtual content::WebContents* GetWebContents() = 0;

 protected:
  virtual ~ConstrainedWebDialogDelegate() {}
};

// ConstrainedWebDialogUI is a facility to show HTML WebUI content
// in a tab-modal constrained dialog.  It is implemented as an adapter
// between an WebDialogUI object and a WebContentsModalDialog object.
//
// Since WebContentsModalDialog requires platform-specific delegate
// implementations, this class is just a factory stub.
// TODO(thestig): Refactor the platform-independent code out of the
// platform-specific implementations.
class ConstrainedWebDialogUI
    : public content::WebUIController {
 public:
  explicit ConstrainedWebDialogUI(content::WebUI* web_ui);
  virtual ~ConstrainedWebDialogUI();

  // WebUIController implementation:
  virtual void RenderViewCreated(
      content::RenderViewHost* render_view_host) OVERRIDE;

  // Sets the delegate on the WebContents.
  static void SetConstrainedDelegate(content::WebContents* web_contents,
                                     ConstrainedWebDialogDelegate* delegate);

 protected:
  // Returns the ConstrainedWebDialogDelegate saved with the WebContents.
  // Returns NULL if no such delegate is set.
  ConstrainedWebDialogDelegate* GetConstrainedDelegate();

 private:
  // JS Message Handler
  void OnDialogCloseMessage(const base::ListValue* args);

  DISALLOW_COPY_AND_ASSIGN(ConstrainedWebDialogUI);
};

// Create a constrained HTML dialog. The actual object that gets created
// is a ConstrainedWebDialogDelegate, which later triggers construction of a
// ConstrainedWebDialogUI object.
// |browser_context| is used to construct the constrained HTML dialog's
//                   WebContents.
// |delegate| controls the behavior of the dialog.
// |tab_delegate| is optional, pass one in to use a custom
//                WebDialogWebContentsDelegate with the dialog, or NULL to
//                use the default one. The dialog takes ownership of
//                |tab_delegate|.
// |overshadowed| is the tab being overshadowed by the dialog.
ConstrainedWebDialogDelegate* CreateConstrainedWebDialog(
    content::BrowserContext* browser_context,
    ui::WebDialogDelegate* delegate,
    ui::WebDialogWebContentsDelegate* tab_delegate,
    content::WebContents* overshadowed);

#endif  // CHROME_BROWSER_UI_WEBUI_CONSTRAINED_WEB_DIALOG_UI_H_


text:
namespace session_manager {
enum class SessionState;
}  // namespace session_manager

namespace extensions {

api::login_state::SessionState SessionStateToApiEnum(
    session_manager::SessionState state);

class LoginStateGetProfileTypeFunction : public ExtensionFunction {
 public:
  DECLARE_EXTENSION_FUNCTION("loginState.getProfileType",
                             LOGINSTATE_GETPROFILETYPE)

 protected:
  ~LoginStateGetProfileTypeFunction() override {}
  ResponseAction Run() override;
};

class LoginStateGetSessionStateFunction : public ExtensionFunction {
 public:
  DECLARE_EXTENSION_FUNCTION("loginState.getSessionState",
                             LOGINSTATE_GETSESSIONSTATE)

 protected:
  ~LoginStateGetSessionStateFunction() override {}
  ResponseAction Run() override;
};

}  // namespace extensions

#endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_LOGIN_SCREEN_LOGIN_STATE_LOGIN_STATE_API_H_


text:
package org.apache.servicecomb.transport.common;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.netflix.config.DynamicPropertyFactory;

public final class TransportConfigUtils {
  private static final Logger LOGGER = LoggerFactory.getLogger(TransportConfigUtils.class);

  private TransportConfigUtils() {
  }

  // old verticle count key is ambiguous
  // suggest to use new name
  public static int readVerticleCount(String key, String deprecatedKey) {
    int count = DynamicPropertyFactory.getInstance().getIntProperty(key, -1).get();
    if (count > 0) {
      return count;
    }

    count = DynamicPropertyFactory.getInstance().getIntProperty(deprecatedKey, -1).get();
    if (count > 0) {
      LOGGER.warn("{} is ambiguous, and deprecated, recommended to use {}.", deprecatedKey, key);
      return count;
    }

    // default value
    count = Runtime.getRuntime().availableProcessors() > 8 ? 8 : Runtime.getRuntime().availableProcessors();
    LOGGER.info("{} not defined, set to {}.", key, count);
    return count;
  }
}


text:
<?php

class m150406_094809_blog_post_quote_type extends yupe\components\DbMigration
{
    public function safeUp()
    {
        $this->alterColumn('{{blog_post}}', 'quote', 'TEXT');
    }
}


text:
package org.kie.remote.services.ws.sei.task;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;
import javax.xml.ws.RequestWrapper;
import javax.xml.ws.ResponseWrapper;

import org.kie.remote.client.jaxb.JaxbTaskSummaryListResponse;
import org.kie.remote.services.ws.sei.ServicesVersion;

/**
 * Only used for initial WSDL generation
 */
@WebService(name = "ProcessService", targetNamespace = TaskWebService.NAMESPACE)
public interface TaskWebService {

    final static String NAMESPACE = "http://services.remote.kie.org/" + ServicesVersion.VERSION + "/task";

    @WebMethod(action = "urn:TaskOperation")
    @WebResult(targetNamespace = "")
    @RequestWrapper(localName = "taskOperation", targetNamespace = NAMESPACE, className = "org.kie.remote.services.ws.wsdl.generated.WrapperTaskOperation")
    @ResponseWrapper(localName = "taskOperationResponse", targetNamespace = "http://services.remote.kie.org/process", className = "org.kie.remote.services.ws.wsdl.generated.WrapperTaskOperationResponse")
    public void taskOperation(@WebParam(name = "arg0", targetNamespace = "") TaskOperationRequest arg0) throws TaskWebServiceException;

    @WebMethod(action = "urn:Query")
    @WebResult(targetNamespace = "")
    @RequestWrapper(localName = "queryTasks", targetNamespace = NAMESPACE, className = "org.kie.remote.services.ws.wsdl.generated.WrapperTaskQueryRequest")
    @ResponseWrapper(localName = "queryTasksResponse", targetNamespace = NAMESPACE, className = "org.kie.remote.services.ws.wsdl.generated.WrapperTaskQueryResponse")
    public JaxbTaskSummaryListResponse query(@WebParam(name = "arg0", targetNamespace = "") TaskQueryRequest arg0) throws TaskWebServiceException;

}


text:
<?php
include_once('../../config/base.config.php');
include_once('../../config/definitions.config.php');
include_once('../../config/smarty.config.php');
include_once('../../objects/Tools.php');
include_once('../../objects/CSSmin.php');
include_once('../../objects/Exception.php');
include_once('../../objects/MySqlDatabase.php');

$id = filter_input(INPUT_GET, "id", FILTER_SANITIZE_NUMBER_INT);

$db = new MySqlDatabase();
$db->connect(_DB_SERVER_, _DB_NAME_, _DB_USER_, _DB_PASSWD_);

Database::$instance = $db;

$db->autocommit(false);
$db->executeQuery("delete from " . _DB_PREFIX_ . "article where id = $id");
$db->executeQuery("delete from " . _DB_PREFIX_ . "article_lang where article_id = $id");
$db->executeQuery("delete from " . _DB_PREFIX_ . "uploaded_files where folder = $id");
$db->executeQuery("delete from " . _DB_PREFIX_ . "video where article_id = $id");
$db->commit();

deleteDir(__NEURO_BASE_URI__. "video/".$id);
deleteDir(__NEURO_BASE_URI__. "admin/uploader/server/php/files/".$id);

function deleteDir($dirPath) {
    if (! is_dir($dirPath)) {
        throw new InvalidArgumentException("$dirPath must be a directory");
    }
    if (substr($dirPath, strlen($dirPath) - 1, 1) != '/') {
        $dirPath .= '/';
    }
    $files = glob($dirPath . '*', GLOB_MARK);
    foreach ($files as $file) {
        if (is_dir($file)) {
            self::deleteDir($file);
        } else {
            unlink($file);
        }
    }
    rmdir($dirPath);
}


text:
package vpp2001

import (
	"github.com/ligato/cn-infra/utils/addrs"

	"go.ligato.io/vpp-agent/v3/plugins/vpp/binapi/vpp2001/interface_types"
	vpp_ip "go.ligato.io/vpp-agent/v3/plugins/vpp/binapi/vpp2001/ip"
	"go.ligato.io/vpp-agent/v3/plugins/vpp/binapi/vpp2001/ip_types"
)

func (h *InterfaceVppHandler) sendAndLogMessageForVpp(ifIdx uint32, addr string, isAdd bool) error {
	req := &vpp_ip.IPContainerProxyAddDel{
		SwIfIndex: interface_types.InterfaceIndex(ifIdx),
		IsAdd:     isAdd,
	}

	IPaddr, isIPv6, err := addrs.ParseIPWithPrefix(addr)
	if err != nil {
		return err
	}

	prefix, _ := IPaddr.Mask.Size()
	req.Pfx.Len = byte(prefix)
	if isIPv6 {
		copy(req.Pfx.Address.Un.XXX_UnionData[:], IPaddr.IP.To16())
		req.Pfx.Address.Af = ip_types.ADDRESS_IP6
	} else {
		copy(req.Pfx.Address.Un.XXX_UnionData[:], IPaddr.IP.To4())
		req.Pfx.Address.Af = ip_types.ADDRESS_IP4
	}
	reply := &vpp_ip.IPContainerProxyAddDelReply{}

	if err := h.callsChannel.SendRequest(req).ReceiveReply(reply); err != nil {
		return err
	}

	return nil
}

func (h *InterfaceVppHandler) AddContainerIP(ifIdx uint32, addr string) error {
	return h.sendAndLogMessageForVpp(ifIdx, addr, true)
}

func (h *InterfaceVppHandler) DelContainerIP(ifIdx uint32, addr string) error {
	return h.sendAndLogMessageForVpp(ifIdx, addr, false)
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>PARDON MAMAN | Tattoo</title>

    <link href="vendor/bootstrap/css/bootstrap.min.css" rel="stylesheet">

    <link href="vendor/font-awesome/css/font-awesome.min.css" rel="stylesheet" type="text/css">
    <link href="https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,400,700,300italic,400italic,700italic" rel="stylesheet"
      type="text/css">

    <link href="css/stylish-portfolio.css" rel="stylesheet">

    <link rel="icon" type="image/png" href="img/favicon.png" />

          Menu

          Accueil

          Tattoo

          Piercing

          Contact

Tattoo

Lorem ipsum dolor sit amet consectetur.

Un tatouage, c'est pour la vie !

Ça a l'air évident, alors pensez-y avant de vous faire tatouer le prénom de votre petit ami(e), ou le dernier tatouage de votre chanteuse préférée…

Nous ne critiquons absolument pas ce genre de démarche, mais nous sommes là pour vous aider
        à affiner ou à développer vos idées et créer ainsi un tatouage unique et original.

Nous n'avons pas de catalogues de modèles à la boutique, mais nous avons pleins d'idées et des références ! Nous nous efforçons de faire une création pour chaque tatouage, ou au moins de personnaliser votre motif.

Vous pouvez bien sûr apporter
        un support (croquis, photo, clé usb) qui servira de base pour l'élaboration du dessin, mais n'oubliez pas, si vous
        trouvez un modèle sur oogle, qu'il a déjà sûrement été tatoué plusieurs centaines de fois… Nous ne faisons pas payer
        la création du motif mais nous ne finalisons le dessin qu'en cas de prise de rendez-vous.

Pour les mineurs :

Les personnes mineures ne peuvent pas se faire tatouer, même avec une autorisation parentale.

Les tatoueurs

Chankar

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nam, voluptate.

Jibé

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nam, voluptate.

Chankar

Lorem ipsum dolor sit amet consectetur, adipisicing elit. Quaerat incidunt illum, magni molestiae optio culpa.

jibe

Lorem ipsum dolor sit amet consectetur, adipisicing elit. Quaerat incidunt illum, magni molestiae optio culpa.

              Pardon Maman

2 Boulevard du Général Gallieni

Bry-sur-Marne, 94360

 09 52 95 67 55

Copyright © Dahlia Drali            et Stéphane Rabenarisoa 2017


text:
"use strict";

const BaseFS = require("./BaseFS.js");
const JSONPathBasedItemFS = require("./JSONPathBasedItemFS.js");
const SitesFS = require("./sitesFS.js");
const fs = require("fs");
const path = require("path");
const recursiveReadDir = require("recursive-readdir");
const utils = require("./utils/utils.js");
const hashes = require("./utils/hashes.js");
const i18n = utils.getI18N(__dirname, ".json", "en");

const singleton = Symbol();
const singletonEnforcer = Symbol();

class PagesFS extends JSONPathBasedItemFS {

    constructor(enforcer) {
        if (enforcer !== singletonEnforcer)
            throw i18n.__("singleton_construct_error", {classname: "PagesFS"});

        // The folderName is passed as "" because it always needs to be calculated dynamically in the getFolderName() method.
        super("pages", "", ".json");
    }

    static get instance() {
        if (!this[singleton]) {
            this[singleton] = new PagesFS(singletonEnforcer);
        }
        return this[singleton];
    }

    /**
     * Get the folder name for storing local artifacts based on the given options.
     *
     * @param {Object} context The API context to be used by the file operation.
     * @param {Object} [opts] Any override options to be used for this operation.
     *
     * @return {String} The folder name for storing local artifacts based on the given options.
     *
     * @override
     */
    getFolderName (context, opts) {
        if (opts && opts.siteItem) {
            return "sites/" + SitesFS.getSiteContextName(opts.siteItem);
        } else {
            return "sites/" + BaseFS.getValidFileName("default");
        }
    }

    /**
     * Returns the file name to use for the provided item.
     *
     * @param {Object} item the item to get the filename for
     *
     * @returns {String} the file name to use for the provided item
     *
     * @override
     */
    getFileName (item) {
        if (item && item.hierarchicalPath) {
            return BaseFS.getValidFileName(item.hierarchicalPath);
        } else {
            return super.getFileName(item);
        }
    }

    /**
     * Create a map of the local artifact files. The map will contain an array of file paths for each item id.
     *
     * @param {Object} context The API context to be used for this operation.
     * @param {Object} opts Any override options to be used for this operation.
     *
     * @return {Object} A map of the local artifact files.
     *
     * @protected
     */
    createLocalFilePathMap (context, opts) {
        // Do not create a map of pages -- renamed pages are handled differently than other path-based items.
        return null;
    }

    /**
     * Sort the given list of items before completing the list operation.
     *
     * @param {Object} context The API context to be used for this operation.
     * @param {Array} items The items to be listed.
     * @param {Object} opts The options to be used for this operations.
     *
     * @returns {Array} The sorted list of items.
     *
     * @protected
     */
    _listSort(context, items, opts) {
        const result = [];
        if (items) {
            // Create a list of parent objects, each of which contain a list of children.
            const root = {children: []};
            const parents = [];
            items.forEach(function (item) {
                // Find the parent of the page item.
                let parent;
                if (!item.parentId) {
                    parent = root;
                } else {
                    parent = parents.find(function (parent) {
                        return parent.id === item.parentId;
                    });

                    if (!parent) {
                        // Create a new parent object and add it to the list.
                        parent = {id: item.parentId, children: [], visited: false};
                        parents.push(parent);
                    }
                }

                // Add the child to its parent.
                parent.children.push(item);
            });

            // Sort each list of child pages by position.
            root.children.sort(function (childA, childB) {
                return childA.position - childB.position;
            });
            parents.forEach(function (parent) {
                parent.children.sort(function (childA, childB) {
                    return childA.position - childB.position;
                });
            });

            const addPagesToResult = function (pages) {
                pages.forEach(function (page) {
                    result.push(page);
                    const parent = parents.find(function (parent) {
                        return parent.id === page.id;
                    });
                    if (parent) {
                        addPagesToResult(parent.children);
                        parent.visited = true;
                    }
                });
            };

            addPagesToResult(root.children);

            // Add any pages from parents that were not visited already. (Typically only necessary for a draft site.)
            parents.forEach(function (parent) {
                if (!parent.visited) {
                    addPagesToResult(parent.children);
                }
            });
        }

        return result;
    }

    /**
     * @param {Object} context The API context to be used by the get operation.
     * @param {Object} opts Any override options to be used for this operation.
     *
     * @returns {Q.Promise} A promise that resolves with the list of all items stored in the working dir.
     *                      There is no guarantee that the names refer to a valid file.
     */
    listNames(context, opts) {
        // Each site in the resulting list should include the contextRoot property.
        opts = utils.cloneOpts(opts);
        if (!opts["additionalItemProperties"]) {
            opts["additionalItemProperties"] = [];
        }
        opts["additionalItemProperties"].push("position");
        opts["additionalItemProperties"].push("parentId");

        return super.listNames(context, opts);
    }

    /**
     * Handle any necessary cleanup of the local file system when an artifact has been renamed.
     *
     * @param {Object} context The API context to be used for this operation.
     * @param {String} id The id of the artifact.
     * @param {String} filePath The (possibly new) filepath of the artifact.
     * @param {Object} opts Any override options to be used for this operation.
     *
     * @protected
     * @override
     */
    handleRename(context, id, filePath, opts) {
        // Only handle the case where the old file name exists and the new file name does not exist.
        const oldFilePath = this.getExistingItemPath(context, id, opts);
        const newFilePath = filePath;
        if (oldFilePath && fs.existsSync(oldFilePath) && !fs.existsSync(newFilePath)) {
            // Note: Because this process uses the current state of the local file system to determine the changes to be
            // made to the local file system, all operations in this method must be done synchronously. Otherwise, some
            // other process could call this method for another file, while this process is paused, and that process
            // could change the state of the local file system in a way that invalidates the actions of this process.

            const fsObject = this;
            const basePath = fsObject.getPath(context, opts);

            const removeEmptyParentDirectory = function (filePath) {
                const parentPath = path.dirname(filePath);
                if (parentPath !== basePath) {
                    // The parent folder is not the virtual folder containing site pages, so delete it if empty.
                    const files = fs.readdirSync(parentPath);
                    if (!files || files.length === 0) {
                        // The parent directory is now empty, so delete it.
                        fs.rmdirSync(parentPath);
                    }
                }
            };

            const fixHashesPath = function (filePath) {
                const fileContents = fs.readFileSync(filePath);
                const item = JSON.parse(fileContents.toString());
                const pathRelativeToBase = utils.getRelativePath(basePath, filePath);
                hashes.setFilePath(context, basePath, item.id, pathRelativeToBase, opts);
            };

            // Delete the old json file for the page.
            fs.unlinkSync(oldFilePath);

            // Handle any children of the renamed page.
            const oldFolderPath = oldFilePath.substr(0, oldFilePath.lastIndexOf('.'));
            const newFolderPath = newFilePath.substr(0, newFilePath.lastIndexOf('.'));
            if (fs.existsSync(oldFolderPath)) {
                // The child pages folder exists for the old page name.
                if (fs.existsSync(newFolderPath)) {
                    // The new folder also exists, so move files from the old folder to the new folder.
                    const oldChildPaths = fsObject.getDescendentFilePaths(oldFolderPath, fsObject.getExtension());
                    oldChildPaths.forEach(function (oldChildPath) {
                        try {
                            const relativeChildPath = utils.getRelativePath(oldFolderPath, oldChildPath);
                            const newChildPath = newFolderPath + relativeChildPath;
                            if (fs.existsSync(newChildPath)) {
                                // The new child file already exists, so just delete the old child file.
                                fs.unlinkSync(oldChildPath);
                            } else {
                                // The new child file does not exist, so move the old child file to the new folder.
                                fs.renameSync(oldChildPath, newChildPath);

                                // Fix the hashes for the child page that was moved.
                                fixHashesPath(newChildPath);
                            }
                        } catch (err) {
                            utils.logWarnings(context, err.toString());
                        }
                    });

                    try {
                        // The old folder should be empty now, so delete it.
                        fs.rmdirSync(oldFolderPath);

                        // So the old page file has been deleted, all children of the old page have been moved/deleted,
                        // and the old page folder has been deleted. Now determine whether to also delete parent folder.
                        removeEmptyParentDirectory(oldFilePath);
                    } catch (err) {
                        utils.logWarnings(context, err.toString());
                    }
                } else {
                    try {
                        // The new folder does not exist, so rename the existing folder containing the child pages.
                        fs.renameSync(oldFolderPath, newFolderPath);

                        // Fix the hashes for the child pages.
                        const newChildPaths = fsObject.getDescendentFilePaths(newFolderPath, fsObject.getExtension());
                        newChildPaths.forEach(function (newChildPath) {
                            fixHashesPath(newChildPath);
                        });

                        // So the old page file has been deleted, and the folder has been renamed. Now determine whether
                        // to also delete parent folder.
                        removeEmptyParentDirectory(oldFilePath);
                    } catch (err) {
                        utils.logWarnings(context, err.toString());
                    }
                }
            } else {
                // So the old page file has been deleted. Now determine whether to also delete the parent folder.
                try {
                    removeEmptyParentDirectory(oldFilePath);
                } catch (err) {
                    utils.logWarnings(context, err.toString());
                }
            }
        } else {
            super.handleRename(context, id, filePath, opts);
        }
    }

    /*
     * Clear the mutable path value.
     */
    clearMutablePath(item) {
        delete item.hierarchicalPath;
    }

    /*
     * Set the mutable path value.
     */
    setMutablePath(item, filePath) {
        item.hierarchicalPath = filePath;
    }
}

module.exports = PagesFS;


text:
import functools
import math

import numpy as np
import tensorflow as tf

try:
    import pandas as pd
except ImportError:
    pd = None

def _get_tensor_types():
    if pd is None:
        return (tf.Tensor, np.ndarray)
    else:
        return (tf.Tensor, np.ndarray, pd.Series, pd.DataFrame)

def convert_inputs_to_tf_dataset(x=None, y=None, sample_weight=None, batch_size=None):
    if sample_weight is not None:
        raise ValueError("RetinaNet does not yet support `sample_weight`.")

    if isinstance(x, tf.data.Dataset):
        if y is not None or batch_size is not None:
            raise ValueError(
                "When `x` is a `tf.data.Dataset`, please do not provide a value for "
                f"`y` or `batch_size`.  Got `y={y}`, `batch_size={batch_size}`."
            )
        return x

    # batch_size defaults to 32, as it does in fit().
    batch_size = batch_size or 32
    # Parse inputs
    inputs = x
    if y is not None:
        inputs = (x, y)

    # Construct tf.data.Dataset
    dataset = tf.data.Dataset.from_tensor_slices(inputs)
    if batch_size == "full":
        dataset = dataset.batch(x.shape[0])
    elif batch_size is not None:
        dataset = dataset.batch(batch_size)
    return dataset

# TODO(lukewood): remove once exported from Keras core.
def train_validation_split(arrays, validation_split):
    """Split arrays into train and validation subsets in deterministic order.

    The last part of data will become validation data.

    Args:
      arrays: Tensors to split. Allowed inputs are arbitrarily nested structures
        of Tensors and NumPy arrays.
      validation_split: Float between 0 and 1. The proportion of the dataset to
        include in the validation split. The rest of the dataset will be
        included in the training split.
    Returns:
      `(train_arrays, validation_arrays)`
    """

    def _can_split(t):
        tensor_types = _get_tensor_types()
        return isinstance(t, tensor_types) or t is None

    flat_arrays = tf.nest.flatten(arrays)
    unsplitable = [type(t) for t in flat_arrays if not _can_split(t)]
    if unsplitable:
        raise ValueError(
            "`validation_split` is only supported for Tensors or NumPy "
            "arrays, found following types in the input: {}".format(unsplitable)
        )

    if all(t is None for t in flat_arrays):
        return arrays, arrays

    first_non_none = None
    for t in flat_arrays:
        if t is not None:
            first_non_none = t
            break

    # Assumes all arrays have the same batch shape or are `None`.
    batch_dim = int(first_non_none.shape[0])
    split_at = int(math.floor(batch_dim * (1.0 - validation_split)))

    if split_at == 0 or split_at == batch_dim:
        raise ValueError(
            "Training data contains {batch_dim} samples, which is not "
            "sufficient to split it into a validation and training set as "
            "specified by `validation_split={validation_split}`. Either "
            "provide more data, or a different value for the "
            "`validation_split` argument.".format(
                batch_dim=batch_dim, validation_split=validation_split
            )
        )

    def _split(t, start, end):
        if t is None:
            return t
        return t[start:end]

    train_arrays = tf.nest.map_structure(
        functools.partial(_split, start=0, end=split_at), arrays
    )
    val_arrays = tf.nest.map_structure(
        functools.partial(_split, start=split_at, end=batch_dim), arrays
    )

    return train_arrays, val_arrays


text:
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

			<title></title>
			<link rel="stylesheet" href="media/stylesheet.css" />
			<meta http-equiv='Content-Type' content='text/html; charset=iso-8859-1'/>

GoogleGeocoding

Description

			Class trees

			Index of elements

Communicator

Classes

CurlCommunicator

FileGetContentsCommunicator

GoogleServiceCommunicator

Files

CurlCommunicator.php

FileGetContentsCommunicator.php

GoogleServiceCommunicator.php

Core

Classes

GoogleGeocodeResponseV3

GoogleGeocodeServiceV3

Files

GoogleGeocodeResponseV3.php

GoogleGeocodeServiceV3.php

phpDocumentor v 1.4.1


text:
# Copyright 2018 Google LLC
#
# 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.

"""This script is used to synthesize generated parts of this library."""
import synthtool as s
from synthtool import gcp

gapic = gcp.GAPICGenerator()
common = gcp.CommonTemplates()

# ----------------------------------------------------------------------------
# Generate error_reporting GAPIC layer
# ----------------------------------------------------------------------------
library = gapic.py_library(
    "errorreporting",
    "v1beta1",
    config_path="/google/devtools/clouderrorreporting" "/artman_errorreporting.yaml",
    artman_output_name="error-reporting-v1beta1",
    include_protos=True,
)

s.move(library / "google/cloud/errorreporting_v1beta1/proto")
s.move(library / "google/cloud/errorreporting_v1beta1/gapic")
s.move(library / "tests/unit/gapic/v1beta1")
s.move(library / "tests/system/gapic/v1beta1")

# Fix up imports
s.replace(
    "google/**/*.py",
    r"from google.devtools.clouderrorreporting_v1beta1.proto import ",
    r"from google.cloud.errorreporting_v1beta1.proto import ",
)

# Fix up docstrings in GAPIC clients
DISCARD_AUTH_BOILERPLATE = r"""
        This endpoint accepts either an OAuth token, or an API key for
        authentication. To use an API key, append it to the URL as the value of
        a ``key`` parameter. For example:

        \.\. raw:: html

POST
            .*

"""

targets = [
    "google/cloud/errorreporting_v1beta1/gapic/*_client.py",
    "google/cloud/errorreporting_v1beta1/gapic/transports/*_transport.py",
]

s.replace(targets, DISCARD_AUTH_BOILERPLATE, r"")

# ----------------------------------------------------------------------------
# Add templated files
# ----------------------------------------------------------------------------
templated_files = common.py_library(unit_cov_level=97, cov_level=100)
s.move(templated_files)

s.shell.run(["nox", "-s", "blacken"], hide_output=False)


text:
package org.elasticsearch.action.admin.indices.upgrade.get;

import org.elasticsearch.action.support.broadcast.BroadcastOperationRequestBuilder;
import org.elasticsearch.client.ElasticsearchClient;

/**
 *
 */
public class UpgradeStatusRequestBuilder extends BroadcastOperationRequestBuilder<UpgradeStatusRequest, UpgradeStatusResponse, UpgradeStatusRequestBuilder> {

    public UpgradeStatusRequestBuilder(ElasticsearchClient client, UpgradeStatusAction action) {
        super(client, action, new UpgradeStatusRequest());
    }
}


text:
#if !defined(_QMGMT_H)
#define _QMGMT_H

#include "condor_classad.h"
#include "condor_io.h"
#include "log_transaction.h" // for Transaction
#include "prio_rec.h"
#include "condor_sockaddr.h"
#include "classad_log.h"

void PrintQ();
class Service;

class QmgmtPeer {

	friend QmgmtPeer* getQmgmtConnectionInfo();
	friend bool setQmgmtConnectionInfo(QmgmtPeer*);
	friend void unsetQmgmtConnection();

	public:
		QmgmtPeer();
		~QmgmtPeer();

		bool set(ReliSock *sock);
		bool set(const condor_sockaddr& raddr, const char *fqOwnerAndDomain);
		void unset();

		bool setEffectiveOwner(char const *o);

		ReliSock *getReliSock() const { return sock; };

		const char *endpoint_ip_str() const;
		const condor_sockaddr endpoint() const;
		const char* getOwner() const;
		const char* getRealOwner() const;
		const char* getFullyQualifiedUser() const;
		int isAuthenticated() const;

	protected:

		char *owner;
		char *fquser;  // owner@domain
		char *myendpoint;
		condor_sockaddr addr;
		ReliSock *sock;

		Transaction *transaction;
		int next_proc_num, active_cluster_num;
		time_t xact_start_time;

	private:
		// we do not allow deep-copies via copy ctor or assignment op,
		// so disable there here by making them private.
		QmgmtPeer(QmgmtPeer&);
		QmgmtPeer & operator=(const QmgmtPeer & rhs);
};

void CloseJobHistoryFile();
void SetMaxHistoricalLogs(int max_historical_logs);
time_t GetOriginalJobQueueBirthdate();
void DestroyJobQueue( void );
int handle_q(Service *, int, Stream *sock);
void dirtyJobQueue( void );
bool SendDirtyJobAdNotification(char *job_id_str);

bool isQueueSuperUser( const char* user );

// Verify that the user issuing a command (test_owner) is authorized
// to modify the given job.  In addition to everything OwnerCheck2()
// does, this also calls IPVerify to check for WRITE authorization.
bool OwnerCheck( ClassAd *ad, const char *test_owner );

// Verify that the user issuing a command (test_owner) is authorized
// to modify the given job.  Either ad or job_owner should be given
// but not both.  If job_owner is NULL, the owner is looked up in the ad.
bool OwnerCheck2( ClassAd *ad, const char *test_owner, char const *job_owner=NULL );

bool BuildPrioRecArray(bool no_match_found=false);
void DirtyPrioRecArray();
extern ClassAd *dollarDollarExpand(int cid, int pid, ClassAd *job, ClassAd *res, bool persist_expansions);
bool rewriteSpooledJobAd(ClassAd *job_ad, int cluster, int proc, bool modify_ad);
ClassAd* GetJobAd(int cluster_id, int proc_id, bool expStartdAd, bool persist_expansions);
ClassAd* GetNextJobByCluster( int, int );

ClassAdLog::filter_iterator BeginIterator(const classad::ExprTree &requirements, int timeslice_ms);
ClassAdLog::filter_iterator EndIterator();

int get_myproxy_password_handler(Service *, int, Stream *sock);

QmgmtPeer* getQmgmtConnectionInfo();
bool OwnerCheck(int,int);

// priority records
extern prio_rec *PrioRec;
extern int N_PrioRecs;
extern HashTable<int,int> *PrioRecAutoClusterRejected;
extern int grow_prio_recs(int);

extern void	FindRunnableJob(PROC_ID & jobid, ClassAd* my_match_ad, char const * user);
extern int Runnable(PROC_ID*);
extern int Runnable(ClassAd*);

extern class ForkWork schedd_forker;

#endif /* _QMGMT_H */


text:
.. _userguide_interaction_widgets:

Adding Widgets
--------------

Widgets are interactive controls that can be added to Bokeh applications to
provide a front end user interface to a visualization. They can drive new computations,
update plots, and connect to other programmatic functionality. When used with the
Bokeh server, widgets can run arbitrary Python code, enabling complex applications.
Widgets can also be used without the Bokeh server in standalone HTML documents through the
browser's Javascript runtime.

To use widgets, you must add them to your document and define their functionality.
Widgets can be added directly to the document root or nested inside a layout. There
are two ways to program a widget's functionality:

    * Use the ``CustomJS`` callback (see :ref:`userguide_interaction_actions_widget_callbacks`). This will work in standalone HTML documents.
    * Use ``bokeh serve`` to start the Bokeh server and set up event handlers with ``.on_change`` (or for some widgets, ``.on_click``).

Event handlers are user-defined Python functions that can be attached to widgets. These functions are
then called when certain attributes on the widget are changed. The necessary function
signature of event handlers is determined by how they are attached to widgets (whether they
are passed through ``.on_change`` or ``.on_click``).

All widgets have an ``.on_change`` method that takes an attribute name and one or more event handlers as
parameters. These handlers are expected to have the function signature, ``(attr, old, new)``,
where ``attr`` refers to the changed attribute's name, and ``old`` and ``new`` refer to the previous and
updated values of the attribute. ``.on_change`` must be used when you need the previous value of an attribute.

.. code-block:: python

    def my_text_input_handler(attr, old, new):
        print("Previous label: " + old)
        print("Updated label: " + new)

    text_input = TextInput(value="default", title="Label:")
    text_input.on_change("value", my_text_input_handler)

Additionally, some widgets, including the button, dropdown, and checkbox, have an ``.on_click`` method that
takes an event handler as its only parameter. For the Button, this handler is called without parameters.
For the other widgets with ``.on_click``, the handler is passed the new attribute value.

.. code-block:: python

    def my_radio_handler(new):
        print 'Radio button option ' + str(new) + ' selected.'

    radio_group = RadioGroup(
        labels=["Option 1", "Option 2", "Option 3"], active=0)
    radio_group.on_click(my_radio_handler)

Bokeh provides a simple default set of widgets, largely based off the Bootstrap
JavaScript library. In the future, it will be possible for users to wrap and use
other widget libraries, or their own custom widgets.

For more information about the attributes to watch using ``.on_change`` or whether ``.on_click`` is
available, go to the :ref:`refguide`. Widgets can be found under :ref:`bokeh.models`.

Button
~~~~~~

Bokeh provides a simple Button:

.. bokeh-plot:: docs/user_guide/examples/interaction_button.py
    :source-position: below

Checkbox Button Group
~~~~~~~~~~~~~~~~~~~~~

Bokeh also provides a checkbox button group, that can have multiple options
selected simultaneously:

.. bokeh-plot:: docs/user_guide/examples/interaction_checkbox_button_group.py
    :source-position: below

Checkbox Group
~~~~~~~~~~~~~~

A standard checkbox:

.. bokeh-plot:: docs/user_guide/examples/interaction_checkbox_group.py
    :source-position: below

Data Table
~~~~~~~~~~

Bokeh provides a sophisticated data table widget based on SlickGrid. Note
that since the table is configured with a data source object, any plots that
share this data source will automatically have selections linked between the
plot and the table (even in static HTML documents).

.. bokeh-plot:: docs/user_guide/examples/interaction_data_table.py
    :source-position: below

Dropdown Menu
~~~~~~~~~~~~~

It is also possible to include Dropdown menus:

.. bokeh-plot:: docs/user_guide/examples/interaction_dropdown_menu.py
    :source-position: below

MultiSelect
~~~~~~~~~~~

A multi-select widget to present multiple available options:

.. bokeh-plot:: docs/user_guide/examples/interaction_multiselect.py
    :source-position: below

Radio Button Group
~~~~~~~~~~~~~~~~~~

A radio button group can have at most one selected button at at time:

.. bokeh-plot:: docs/user_guide/examples/interaction_radio_button_group.py
    :source-position: below

Radio Group
~~~~~~~~~~~

A radio group uses standard radio button appearance:

.. bokeh-plot:: docs/user_guide/examples/interaction_radio_group.py
    :source-position: below

Select
~~~~~~

A single selection widget:

.. bokeh-plot:: docs/user_guide/examples/interaction_select.py
    :source-position: below

Slider
~~~~~~

The Bokeh slider can be configured with ``start`` and ``end`` values, a ``step`` size,
an initial ``value`` and a ``title``:

.. bokeh-plot:: docs/user_guide/examples/interaction_slider.py
    :source-position: below

RangeSlider
~~~~~~~~~~~

The Bokeh range-slider can be configured with ``start`` and ``end`` values, a ``step`` size,
an initial ``range`` and a ``title``:

.. bokeh-plot:: source/docs/user_guide/source_examples/interaction_range_slider.py
    :source-position: below

Tab Panes
~~~~~~~~~

Tab panes allow multiple plots or layouts to be show in selectable tabs:

.. bokeh-plot:: docs/user_guide/examples/interaction_tab_panes.py
    :source-position: below

TextInput
~~~~~~~~~

A widget for collecting a line of text from a user:

.. bokeh-plot:: docs/user_guide/examples/interaction_textinput.py
    :source-position: below

Toggle Button
~~~~~~~~~~~~~

The toggle button holds an on/off state:

.. bokeh-plot:: docs/user_guide/examples/interaction_toggle_button.py
    :source-position: below

.. _userguide_interaction_actions:

Div
~~~

A widget for displaying text that can support HTML in a <div> tag:

.. bokeh-plot:: docs/user_guide/examples/interaction_div.py
    :source-position: below

Paragraph
~~~~~~~~~

A widget for displaying a block of text in an HTML <p> tag:

.. bokeh-plot:: docs/user_guide/examples/interaction_paragraph.py
    :source-position: below

PreText
~~~~~~~

A widget for displaying a block of pre-formatted text in an HTML <pre> tag:

.. bokeh-plot:: docs/user_guide/examples/interaction_pretext.py
    :source-position: below


text:
title: IntelliSense in VS Code
MetaDescription: IntelliSense is a fundamental feature for Visual Studio Code. In this article, learn how to use IntelliSense for JavaScript in VS Code.
commitid: 42757495f4d9a4a7a959e45a7eb459c388b04aaf
---

In this tutorial, we show you how to set up IntelliSense for a JavaScript project.

> Note: For IntelliSense with other programming languages, consult the language extension's README. You can learn more about language support [here](/docs/languages/overview.md).

## Outline

* IntelliSense basics
* Parameter Info
* Go To Definition
* JSON IntelliSense
* Enabling IntelliSense for other languages

## Learn More

* [JavaScript IntelliSense](/docs/languages/javascript.md#intellisense) - Define a JavaScript project with `jsconfig.json` to get IntelliSense across files.
* [Code Navigation](/docs/userguide/editingevolved.md) - Move quickly through your source code.
* [Node.js Tutorial](/docs/nodejs/nodejs-tutorial.md) - See IntelliSense in action for Node.js.

## Next Video

* [Debugging](/docs/introvideos/debugging.md) - Learn how to debug your application, including setting breakpoints and inspecting variables.


text:
// Copyright 2018 Google LLC
//
// 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.google.cloud.healthcare.util;

import static org.junit.Assert.assertNotNull;

import com.google.common.io.ByteStreams;
import java.io.IOException;
import java.io.InputStream;
import org.dcm4che3.io.DicomInputStream;

/** Utility methods for tests. */
public class TestUtils {
  public static final String TEST_MR_FILE = "mr_1.0.0.0.dcm";
  public static final String TEST_IMG_FILE = "img_1.0.0.0.dcm";

  private TestUtils() {}

  public static byte[] readTestFile(String testFile) throws IOException {
    return ByteStreams.toByteArray(streamTestFile(testFile));
  }

  public static InputStream streamTestFile(String testFile) throws IOException {
    InputStream in = TestUtils.class.getClassLoader().getResourceAsStream(testFile);
    assertNotNull("test file missing: " + testFile, in);
    return in;
  }

  // Loads a DICOM file and strips file meta headers. This matches the behavior of how DICOM
  // binary instances are transmitted in DIMSE.
  // https://groups.google.com/forum/#!searchin/comp.protocols.dicom/file$20meta$20header%7Csort:date/comp.protocols.dicom/L1NL1VB6KTA/F9bH3GNf2EMJ
  public static InputStream streamDICOMStripHeaders(String testFile) throws IOException {
    DicomInputStream in = new DicomInputStream(TestUtils.streamTestFile(testFile));
    // Read and discard the meta-header in the stream (advances stream past meta header bytes).
    in.getFileMetaInformation();
    return in;
  }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="news_title">nieuws</string>
    <string name="video_title">video</string>
    <string name="discover_title">ontdek</string>

    <array name="better_bottom_bar_accessibility_title">
        <item>@string/news_title</item>
        <item>@string/video_title</item>
        <item>@string/discover_title</item>
    </array>
</resources>


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Man. Brit. Discomyc. (London) 222 (1887)

#### Original name
Humaria carneosanguinea Fuckel, 1870

### Remarks
null