text:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE supplementalData SYSTEM "../../common/dtd/ldmlSupplemental.dtd">
<!-- Copyright © 1991-2015 Unicode, Inc.
CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
For terms of use, see http://www.unicode.org/copyright.html -->
<supplementalData>
	<version number="$Revision$" />
	<transforms>
		<transform source="zu" target="zu_FONIPA" direction="forward" alias="zu-fonipa-t-zu">
			<tRule><![CDATA[
# Pronunciation rules for isiZulu.
#
# Author: mjansche@google.com (Martin Jansche)
#
# These rules transcribe isiZulu into the phoneme inventory used within the
# NCHLT Speech Corpus (https://sites.google.com/site/nchltspeechcorpus/home).
#
# The rules were tested using the NCHLT-inlang isiZulu pronunciation dictionary
# (http://rma.nwu.ac.za/index.php/resource-catalogue/nchlt-inlang-dictionaries.html).
# They correctly account for all 15,000 entries in the dictionary.
#
# The NCHLT 2013 phone set does not indicate tone in any way. Transcription of
# tone is out of scope without a dictionary, since tone is generally not
# indicated in the orthography. Nasal clicks are not treated as separated
# phonemes in the NCHLT 2013 phone set and are transcribed as a sequence of
# nasal plus click instead.
#
# One minor notational deviation from the NCHLT 2013 phone set is that we use a
# tie bar within the complex (depressor) clicks, e.g. ɡ͡ǀ instead of ɡǀ, to
# avoid ambiguity and make the phoneme inventory uniquely decodable.

::Lower;

tsh → t͡ʃ';

bh → b;
ch → ǀʰ;
dl → ɮ;
gc → ɡ͡ǀ;
gq → ɡ͡ǃ;
gx → ɡ͡ǁ;
hh → ɦ;  # To investigate: /ɦ/ and /h/ may be switched in the NCHLT dictionary.
hl → ɬ;
kh → kʰ;
kl → k͡ɬ;
ny → ɲ;
ph → pʰ;
qh → ǃʰ;
n { sh → t͡s';
    sh → ʃ;
th → tʰ;
xh → ǁʰ;

a → a;
m { b → b;
    b → ɓ;
c → ǀ;
d → d;
e → ɛ;
f → f;
g → ɡ;
h → h;
i → i;
j → d͡ʒ;
k → k;
l → l;
m → m;
[$] { n } gc → n;
      n } [gk] → ŋ;
      n } j → ɲ;
n → n;
o → ɔ;
p → p';
q → ǃ;
n { s → t͡s';
    s → s;
t → t';
u → u;
v → v;
w → w;
x → ǁ;
y → j;
n { z → d͡z;
    z → z;
			]]></tRule>
		</transform>
	</transforms>
</supplementalData>


text:
package org.apache.nifi.authorization;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import org.apache.commons.io.IOUtils;
import org.apache.nifi.controller.serialization.FlowFromDOMFactory;
import org.apache.nifi.security.xml.XmlUtils;
import org.apache.nifi.util.LoggingXmlParserErrorHandler;
import org.apache.nifi.util.file.FileUtils;
import org.apache.nifi.web.api.dto.PortDTO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * Parses a flow and returns the root group id and root group ports.
 */
public class FlowParser {

    private static final Logger logger = LoggerFactory.getLogger(FlowParser.class);

    private static final String FLOW_XSD = "/FlowConfiguration.xsd";

    private final Schema flowSchema;

    public FlowParser() throws SAXException {
        SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        flowSchema = schemaFactory.newSchema(FlowParser.class.getResource(FLOW_XSD));
    }

    /**
     * Extracts the root group id from the flow configuration file provided in nifi.properties, and extracts
     * the root group input ports and output ports, and their access controls.
     *
     */
    public FlowInfo parse(final File flowConfigurationFile) {
        if (flowConfigurationFile == null) {
            logger.debug("Flow Configuration file was null");
            return null;
        }

        // if the flow doesn't exist or is 0 bytes, then return null
        final Path flowPath = flowConfigurationFile.toPath();
        try {
            if (!Files.exists(flowPath) || Files.size(flowPath) == 0) {
                logger.warn("Flow Configuration does not exist or was empty");
                return null;
            }
        } catch (IOException e) {
            logger.error("An error occurred determining the size of the Flow Configuration file");
            return null;
        }

        // otherwise create the appropriate input streams to read the file
        try (final InputStream in = Files.newInputStream(flowPath, StandardOpenOption.READ);
             final InputStream gzipIn = new GZIPInputStream(in)) {

            final byte[] flowBytes = IOUtils.toByteArray(gzipIn);
            if (flowBytes == null || flowBytes.length == 0) {
                logger.warn("Could not extract root group id because Flow Configuration File was empty");
                return null;
            }

            // create validating document builder
            final DocumentBuilder docBuilder = XmlUtils.createSafeDocumentBuilder(flowSchema);
            docBuilder.setErrorHandler(new LoggingXmlParserErrorHandler("Flow Configuration", logger));

            // parse the flow
            final Document document = docBuilder.parse(new ByteArrayInputStream(flowBytes));

            // extract the root group id
            final Element rootElement = document.getDocumentElement();

            final Element rootGroupElement = (Element) rootElement.getElementsByTagName("rootGroup").item(0);
            if (rootGroupElement == null) {
                logger.warn("rootGroup element not found in Flow Configuration file");
                return null;
            }

            final Element rootGroupIdElement = (Element) rootGroupElement.getElementsByTagName("id").item(0);
            if (rootGroupIdElement == null) {
                logger.warn("id element not found under rootGroup in Flow Configuration file");
                return null;
            }

            final String rootGroupId = rootGroupIdElement.getTextContent();

            final List<PortDTO> ports = new ArrayList<>();
            ports.addAll(getPorts(rootGroupElement, "inputPort"));
            ports.addAll(getPorts(rootGroupElement, "outputPort"));

            return new FlowInfo(rootGroupId, ports);

        } catch (final SAXException | ParserConfigurationException | IOException ex) {
            logger.error("Unable to parse flow {} due to {}", new Object[] { flowPath.toAbsolutePath(), ex });
            return null;
        }
    }

    /**
     * Generates a {@link Document} from the flow configuration file provided
     */
    public Document parseDocument(final File flowConfigurationFile) {
        if (flowConfigurationFile == null) {
            logger.debug("Flow Configuration file was null");
            return null;
        }

        // if the flow doesn't exist or is 0 bytes, then return null
        final Path flowPath = flowConfigurationFile.toPath();
        try {
            if (!Files.exists(flowPath) || Files.size(flowPath) == 0) {
                logger.warn("Flow Configuration does not exist or was empty");
                return null;
            }
        } catch (IOException e) {
            logger.error("An error occurred determining the size of the Flow Configuration file");
            return null;
        }

        // otherwise create the appropriate input streams to read the file
        try (final InputStream in = Files.newInputStream(flowPath, StandardOpenOption.READ);
             final InputStream gzipIn = new GZIPInputStream(in)) {

            final byte[] flowBytes = IOUtils.toByteArray(gzipIn);
            if (flowBytes == null || flowBytes.length == 0) {
                logger.warn("Could not extract root group id because Flow Configuration File was empty");
                return null;
            }

            // create validating document builder
            final DocumentBuilder docBuilder = XmlUtils.createSafeDocumentBuilder(flowSchema);
            docBuilder.setErrorHandler(new LoggingXmlParserErrorHandler("Flow Configuration", logger));
            return docBuilder.parse(new ByteArrayInputStream(flowBytes));

        } catch (final SAXException | ParserConfigurationException | IOException ex) {
            logger.error("Unable to parse flow {} due to {}", new Object[]{flowPath.toAbsolutePath(), ex});
            return null;
        }
    }

    /**
     * Gets the ports that are direct children of the given element.
     *
     * @param element the element containing ports
     * @param type the type of port to find (inputPort or outputPort)
     * @return a list of PortDTOs representing the found ports
     */
    private List<PortDTO> getPorts(final Element element, final String type) {
        final List<PortDTO> ports = new ArrayList<>();

        // add input ports
        final List<Element> portNodeList = getChildrenByTagName(element, type);
        for (final Element portElement : portNodeList) {
            final PortDTO portDTO = FlowFromDOMFactory.getPort(portElement);
            portDTO.setType(type);
            ports.add(portDTO);
        }

        return  ports;
    }

    /**
     * Writes a given XML Flow out to the specified path.
     *
     * @param flowDocument flowDocument of the associated XML content to write to disk
     * @param flowXmlPath  path on disk to write the flow
     * @throws IOException if there are issues in accessing the target destination for the flow
     * @throws TransformerException if there are issues in the xml transformation process
     */
    public void writeFlow(final Document flowDocument, final Path flowXmlPath) throws IOException, TransformerException {
        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        final Source xmlSource = new DOMSource(flowDocument);
        final Result outputTarget = new StreamResult(outputStream);
        TransformerFactory.newInstance().newTransformer().transform(xmlSource, outputTarget);
        final InputStream is = new ByteArrayInputStream(outputStream.toByteArray());

        try (final OutputStream output = Files.newOutputStream(flowXmlPath, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
             final OutputStream gzipOut = new GZIPOutputStream(output)) {
            FileUtils.copy(is, gzipOut);
        }
    }

    /**
     * Finds child elements with the given tagName.
     *
     * @param element the parent element
     * @param tagName the child element name to find
     * @return a list of matching child elements
     */
    public static List<Element> getChildrenByTagName(final Element element, final String tagName) {
        final List<Element> matches = new ArrayList<>();
        final NodeList nodeList = element.getChildNodes();
        for (int i = 0; i < nodeList.getLength(); i++) {
            final Node node = nodeList.item(i);
            if (!(node instanceof Element)) {
                continue;
            }

            final Element child = (Element) nodeList.item(i);
            if (child.getNodeName().equals(tagName)) {
                matches.add(child);
            }
        }
        return matches;
    }
}

redpajama_set_name: RedPajamaGithub


text:
body .b-form-radio__colorpicker .b-form-radio__button_color_blue .b-form-radio__inner
{
    background: #00f;
}


text:
@import url(code.css);

#content.ticket {
 width: 58em;
 max-width: 100%;
 margin-left: auto;
 margin-right: auto;
}

#field-description-help { float: right }
#properties div.trac-resizable, #field-description { width: 100% }

/* "Yellow Ticket Box" */
#ticket {
 background: #ffd;
 border: 1px solid #dd9;
 border-radius: .4em;
 margin-top: 1em;
 padding: .5em 1em;
 position: relative;
}

/* YTB in preview mode */
#ticket.ticketdraft {
 background: #f8f8f8 url(../draft.png);
}
#ticketchange.ticketdraft {
 padding: 0 1em;
 margin: 1em 0;
}
#ticketchange.ticketdraft h3 {
 margin-top: .5em;
}
.preview-notice { font-weight: bold; }

.ticketdraft {
 background: #f8f8f8 url(../draft.png);
 border: 1px solid #d7d7d7;
 border-radius: .4em;
 padding: 0 .2em;
}

#trac-ticket-title {
 margin-top: .4em;
 margin-right: 0;
 clear: right;
}

#ticket > h2 {
 color: #844;
 margin: .3em 0 .4em 0;
}
#ticket > h2 .trac-id {
 font-size: 145%;
 vertical-align: middle;
 margin: 0 .4em 0 0;
}
#ticket > h2 .trac-status {
 vertical-align: middle;
}
#ticket > h2 .trac-type {
 color: #955;
 vertical-align: middle;
}
#ticket > h2 .trac-resolution {
 vertical-align: middle;
}

#ticket .date {
 color: #996;
 float: right;
 font-size: 85%;
 position: relative;
 top: -.2em;
}
#ticket .date p { margin: .3em }

#ticket table.properties {
 clear: both;
 border-top: 1px solid #dd9;
 border-collapse: collapse;
 table-layout: fixed;
 width: 100%;
}
#ticket table.properties tr { border-bottom: 1px dotted #eed }
#ticket table.properties td, #ticket table.properties th {
 font-size: 80%;
 padding: .5em 1em;
 vertical-align: top;
}
#ticket table.properties th {
 color: #663;
 font-weight: normal;
 text-align: left;
 width: 20%;
}
#ticket table.properties th.missing { color: #d3d398; }
#ticket table.properties td { width: 30% }
#ticket table.properties td p:first-child { margin-top: 0 }
#ticket table.properties td p:last-child { margin-bottom: 0 }
#ticket table.properties .description { border-top: 1px solid #dd9 }

#ticket .description h3 {
 border-bottom: 1px solid #dd9;
 color: #663;
 font-size: 100%;
 font-weight: normal;
}
#ticket .description h3 .lastmod {
 font-size: 90%;
}
#ticket .inlinebuttons {
 float: right;
 position: relative;
 bottom: 0.3em;
}

/* Change History */
#changelog {
 padding: 1em;
}
.trac-shade { background-color: #eee }
#trac-threaded-form { float: right }

/* Threaded comments */
ul.children {
 margin-top: 1.5em;
 padding-left: 2em;
 list-style-image: url(../inreply.png);
}
ul.children > li.child {
 padding-left: .5em;
 margin-bottom: 1.5em;
 border-left: 1px solid #bbb;
 border-radius: 1em;
}

/* Comment contents */
#changelog h3, #ticketchange h3 {
 border-bottom: 1px solid #d7d7d7;
 box-shadow: .1em .4em .7em 0 #f2f2f2;
 padding: 0 .2em;
 margin-bottom: .5em;
 color: #999;
 font-size: 100%;
 font-weight: normal;
}
@media print {
 #changelog h3, #ticketchange h3 { box-shadow: none }
}

div.comment ul { list-style: disc }
div.comment ul ul, div.comment ol ul { list-style: circle }
div.comment ul ul ul, div.comment ol ul ul { list-style: square }
div.comment ul ol ul, div.comment ol ol ul { list-style: square }
div.comment ol { list-style: decimal }

/* Comment editor */
#trac-comment-editor { margin-left: 2em; margin-bottom: 1em }
#trac-comment-editor div.trac-resizable { width: 100% }
#trac-comment-editor textarea {
 background: #ffffe0;
 margin-left: -1px;
 margin-right: -1px;
 width: 100%;
}
#trac-comment-editor .wikitoolbar { margin-left: -1px }
.trac-new { border-left: 0.31em solid #c0f0c0; padding-left: 0.31em; }

.trac-loading {
  background: url(../loading.gif) 0 50% no-repeat;
  margin: 0 1em;
  padding-left: 16px;
  display: none;
}
.threading, #changelog .inlinebuttons {
 float: right;
}
.threading { font-size: 85%; }
.threading :link, .threading :visited { border-bottom: 0 }
#changelog .trac-lastedit {
 padding-left: 2.5em;
 margin-top: .8em;
 color: #999;
 font-size: 80%;
}
#changelog .trac-lastedit :link, #changelog .trac-lastedit :visited { color: inherit }

#changelog .changes, #ticketchange .changes { list-style: square; margin-left: 2em; padding: 0 }
.trac-conflict { border-left: .3em solid #e44; padding-left: .3em; }
#changelog .comment, #ticketchange .comment { margin-left: 2em }
button.trac-revert, button.trac-revert:hover {
 margin: 0;
 padding: 0;
 border: none;
 border-bottom: 1px dotted #bbb;
 overflow: visible;
 cursor: pointer;
 background: none;
 color: #b00;
 text-decoration: none;
 -moz-user-select: text;
}
button.trac-revert:hover { background-color: #eee; color: #555; }
button.trac-revert div { display: none; }

form .field { margin-top: .75em; width: 100% }
form .field fieldset { margin-left: 1px; margin-right: 1px }
label[for=comment] { float: right }
#comment { margin-left: -1px; margin-right: -1px; padding: 0; width: 100% }
form .field .wikitoolbar { margin-left: -1px }
form .field div.trac-resizable { width: 100% }

#propertyform { margin-bottom: 2em; }
#properties { white-space: nowrap; line-height: 160%; padding: .5em }
#properties table { border-spacing: 0; width: 100%; padding: 0 .5em }
#properties table th {
 padding: .4em;
 text-align: right;
 width: 20%;
 vertical-align: top;
}
#properties table th.col2 { border-left: 1px dotted #d7d7d7 }
#properties table td { vertical-align: middle; width: 30% }
#properties table td.fullrow { vertical-align: middle; width: 80% }

#action { line-height: 2em }

fieldset.radio { border: none; margin: 0; padding: 0 }
fieldset.radio legend {
 color: #000;
 float: left;
 font-size: 100%;
 font-weight: normal;
 padding: 0 1em 0 0;
}
fieldset.radio label { padding-right: 1em }


text:
package org.apache.geronimo.console.servermanager;

import java.io.IOException;

import javax.portlet.ActionRequest;
import javax.portlet.ActionResponse;
import javax.portlet.PortletConfig;
import javax.portlet.PortletException;
import javax.portlet.PortletRequestDispatcher;
import javax.portlet.RenderRequest;
import javax.portlet.RenderResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.geronimo.console.BasePortlet;
import org.apache.geronimo.kernel.Kernel;
import org.apache.geronimo.kernel.KernelRegistry;
import org.apache.geronimo.system.main.Daemon;

public class ServerManagerPortlet extends BasePortlet {

    private static final Log log = LogFactory.getLog(ServerManagerPortlet.class);

    private PortletRequestDispatcher normalView;

    private PortletRequestDispatcher shutdownView;

    private PortletRequestDispatcher helpView;

    private Kernel kernel;

    public void processAction(ActionRequest actionRequest,
            ActionResponse actionResponse) throws PortletException, IOException {
        if (actionRequest.getParameter("reboot") != null) {
            log.info("Reboot initiated by user request: " + actionRequest.getUserPrincipal().getName());
            new Thread() {
                public void run() {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                    }
                    kernel.shutdown();
                    Daemon.main(new String[0]);
                }
            }.start();
        }
    }

    protected void doView(RenderRequest request, RenderResponse response)
            throws PortletException, IOException {
        if (request.getParameter("shutdown") != null) {
            log.info("Shutting down by user request: " + request.getUserPrincipal().getName());
            shutdownView.include(request, response);
            response.flushBuffer();
            kernel.shutdown();
            System.exit(0);
        } else {
            normalView.include(request, response);
        }
    }

    protected void doHelp(RenderRequest renderRequest,
            RenderResponse renderResponse) throws PortletException, IOException {
        helpView.include(renderRequest, renderResponse);
    }

    public void init(PortletConfig portletConfig) throws PortletException {
        super.init(portletConfig);
        normalView = portletConfig.getPortletContext().getRequestDispatcher(
                "/WEB-INF/view/servermanager/normal.jsp");
        shutdownView = portletConfig.getPortletContext().getRequestDispatcher(
                "/WEB-INF/view/servermanager/shutdown.jsp");
        helpView = portletConfig.getPortletContext().getRequestDispatcher(
                "/WEB-INF/view/servermanager/help.jsp");
        kernel = KernelRegistry.getSingleKernel();
    }

    public void destroy() {
        normalView = null;
        shutdownView = null;
        helpView = null;
        super.destroy();
    }

}


text:
layout: default
---

{{ page.title | markdownify | strip_html }}

        <time datetime="{{ page.date }}" is="time-ago" title="{{ page.date }}">{{ page.date | date_to_string }}</time>

    {% if site.show_bylines == true %}

{{ site.data.people[page.author].name }}

        {% if site.github_hosted == true %}

        {% endif %}
    {% endif %}

    {% if page.updated == true %}

            This post has been updated since it was first published. To view all the changes, visit GitHub

    {% endif %}

        {{ content }}

</div


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <TITLE>Generic Image Library: is_iterator_adaptor Struct Template Reference</TITLE>
    <META HTTP-EQUIV="content-type" CONTENT="text/html;charset=ISO-8859-1"/>
    <LINK TYPE="text/css" REL="stylesheet" HREF="adobe_source.css"/>

Modules
                  | Alphabetical List
                  | Class List
                  | Directories
                  | File List
                  | GIL Home Page

boost::gil::is_iterator_adaptor

is_iterator_adaptor Struct Template Reference
#include <pixel_iterator.hpp>

Detailed Description

template<typename It>

 struct boost::gil::is_iterator_adaptor< It >

metafunction predicate determining whether the given iterator is a plain one or an adaptor over another iterator. Examples of adaptors are the step iterator and the dereference iterator adaptor.

The documentation for this struct was generated from the following file:

pixel_iterator.hpp

<address style="text-align: right;">Generated on Sat May 2 13:50:18 2009 for Generic Image Library by

 1.5.6 </address>


text:
package com.distelli.europa.pipeline;

import com.distelli.europa.models.ContainerRepo;
import com.distelli.europa.models.Pipeline;
import com.distelli.europa.models.PipelineComponent;
import com.google.inject.Injector;
import javax.inject.Inject;
import javax.inject.Singleton;
import lombok.extern.log4j.Log4j;

@Log4j
@Singleton
public class RunPipeline {
    @Inject
    private Injector _injector;

    public void runPipeline(Pipeline pipeline, ContainerRepo repo, String tag, String digest) {
        for ( PipelineComponent component : pipeline.getComponents() ) {
            try {
                _injector.injectMembers(component);
                if ( ! component.execute(repo, tag, digest) ) break;
            } catch ( Exception ex ) {
                // Ignore exceptions caused by threads being interrupted:
                if ( ex instanceof java.io.InterruptedIOException ) return;
                log.error(ex.getMessage(), ex);
            }
        }
    }
}


text:
package org.ibm.fis.spring_boot_soap;

import org.springframework.stereotype.Component;

/**
 * A sample transform
 */
@Component(value = "myTransformer")
public class MyTransformer {

    public String transform() {
        // lets return a random string
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < 3; i++) {
            int number = (int) (Math.round(Math.random() * 1000) % 10);
            char letter = (char) ('0' + number);
            buffer.append(letter);
        }
        return buffer.toString();
    }

}


text:
var app = app || {};

app.BookProfileView = Backbone.View.extend({
  tagName: 'div',
  className: 'bl-book-container col s12 m3 l3',
  template: _.template( $( '#bookProfileTemplate' ).html() ),
  initialize: function (options) {
    var bookProfileView;
    this.collection = app.libraryCollection;
    bookProfileView = this;
    this.bookId = options.bookId;
    app.libraryCollection.fetch({
      reset: true,
      success: function() {

        if (app.libraryCollection.length) {
          bookProfileView.model = app.libraryCollection.get(bookProfileView.bookId);
          this.$('#book_profile').html(bookProfileView.render().el);
        } else {
          app.router.navigateToHome();
        }
      },
      error: function() {
        app.router.navigateToHome();
      }
    });
  },
  render: function() {
    this.$el.html( this.template( this.model.attributes ) );
    return this;
  },
  showBookProfile: function() {
    $('#book_profile').addClass('active_page');
  },
  hideBookProfile: function() {
    $('#book_profile').removeClass('active_page');
  }

});


text:
<?php

require_once '../../../vendor/autoload.php';
require_once '../../../apikey.php';

$token  = new \Tmdb\ApiToken(TMDB_API_KEY);
$client = new \Tmdb\Client($token, ['session_token' => new \Tmdb\SessionToken(TMDB_SESSION_TOKEN)]);

$accountRepository = new \Tmdb\Repository\AccountRepository($client);
$account           = $accountRepository->getAccount();

var_dump($account);


text:
(function (phantomas) {
  phantomas.spyEnabled(false, "initializing hidden content analysis");

  window.addEventListener("load", () => {
    var runner = new phantomas.nodeRunner(),
      lazyLoadableImages = {};

    phantomas.spyEnabled(false, "analyzing hidden content");

    runner.walk(document.body, (node) => {
      switch (node.nodeType) {
        case Node.ELEMENT_NODE:
          // @see https://developer.mozilla.org/en/DOM%3awindow.getComputedStyle
          var styles = window.getComputedStyle(node);

          if (styles && styles.getPropertyValue("display") === "none") {
            if (typeof node.innerHTML === "string") {
              var size = node.innerHTML.length;
              phantomas.incrMetric("hiddenContentSize", size);

              // log hidden containers bigger than 1 kB
              if (size > 1024) {
                phantomas.addOffender(
                  "hiddenContentSize",
                  phantomas.getDOMPath(node) + " (" + size + " characters)"
                );
              }
            }

            // count hidden images that can be lazy loaded (issue #524)
            var images = [];
            if (node.tagName === "IMG") {
              images = [node];
            } else if (typeof node.querySelectorAll === "function") {
              images = node.querySelectorAll("img") || [];
            }

            for (var i = 0, len = images.length; i < len; i++) {
              var src = images[i].src,
                path;

              if (src === "" || src.indexOf("data:image") === 0) continue;

              if (!lazyLoadableImages[src]) {
                path = phantomas.getDOMPath(images[i]);

                lazyLoadableImages[src] = {
                  path: path,
                };
              }
            }

            // don't run for child nodes as they're hidden as well
            return false;
          }
          break;
      }
    });

    Object.keys(lazyLoadableImages).forEach((img) => {
      var entry = lazyLoadableImages[img];

      phantomas.incrMetric("hiddenImages");
      phantomas.addOffender("hiddenImages", img);

      phantomas.log(
        "hiddenImages: <%s> image (%s) is hidden and can be lazy-loaded",
        img,
        entry.path
      );
    });

    phantomas.spyEnabled(true);
  });

  phantomas.spyEnabled(true);
})(window.__phantomas);


text:
#ifndef GLOBUS_XIO_GRIDFTP_DRIVER_H
#define GLOBUS_XIO_GRIDFTP_DRIVER_H

/**
 * @file globus_xio_gridftp_driver.h
 * @brief XIO GRIDFTP Client Driver
 */

#include "globus_xio_system.h"
#include "globus_common.h"

#ifndef GLOBUS_GLOBAL_DOCUMENT_SET
/**
 * @mainpage Globus XIO GridFTP Driver
 * @copydoc globus_xio_gridftp_driver
 */
#endif

/**
 * @defgroup globus_xio_gridftp_driver Globus XIO GRIDFTP Client Driver
 * @brief Globus XIO GRIDFTP Client Driver
 */

/**
 * @addtogroup globus_xio_gridftp_driver
 * @section globus_xio_gridftp_driver_handles Handles
 *
 * An XIO handle with the gridftp client driver can be created with
 * globus_xio_handle_create()
 *
 * The GridFTP client driver makes use of globus ftp client library.
 * globus_xio_register_open() call creates a new ftp client handle (unless
 * one is set on the attr passed), establishes connection with the
 * GridFTP server. The contact string must contain the scheme, host name,
 * and the resource, optionally it might contain port and subject also.
 *
 * When the XIO handle is closed, the GridFTP driver will destroy its internal
 * resources and the ftp client handle (unless this handle was set on an attr).
 */

/**
 * @addtogroup globus_xio_gridftp_driver
 * @section globus_xio_gridftp_driver_io Reading/Writing
 *
 * The globus_xio_register_read() enforce that the waitforbytes parameter
 * should be one. When multiple TCP streams are used between the client and the
 * server, data might not be delivered in order.
 * globus_xio_data_descriptor_cntl() can be used to get the offset of the
 * data.
 *
 * globus_xio_register_write() does not enforce any restriction on the
 * waitforbytes parameter.
 *
 * In any case, when an error or EOF occurs before the waitforbytes request
 * has been met, the outgoing nbytes is set to the amount of data actually
 * read/written before the error or EOF occurred.
 */

/**
 * @addtogroup globus_xio_gridftp_driver
 *
 * @section globus_xio_gridftp_driver_env Environment Variables
 *
 * - GLOBUS_XIO_GRIDFTP_DEBUG Available if using a debug build. See
 * globus_debug.h for format.
 */

/**
 * @addtogroup globus_xio_gridftp_driver
 * @section globus_xio_gridftp_driver_cntls Attributes and Cntls
 *
 * GridFTP driver specific attrs and cntls.
 *
 * @see globus_xio_attr_cntl ()
 *
 * @see globus_xio_handle_cntl ()
 *
 * @see globus_xio_data_descriptor_cntl ()
 */
#define globus_xio_gridftp_attr_cntl globus_xio_attr_cntl
#define globus_xio_gridftp_handle_cntl globus_xio_handle_cntl

/**
 * @addtogroup globus_xio_gridftp_driver
 * @section globus_xio_gridftp_driver_types Types
 *
 * The errors reported by the GRIDFTP driver include GLOBUS_XIO_ERROR_EOF,
 * GLOBUS_XIO_ERROR_CANCELED, @ref GLOBUS_XIO_GRIDFTP_ERROR_OUTSTANDING_READ,
 * @ref GLOBUS_XIO_GRIDFTP_ERROR_SEEK,
 * @ref GLOBUS_XIO_GRIDFTP_ERROR_OUTSTANDING_WRITE,
 * @ref GLOBUS_XIO_GRIDFTP_ERROR_PENDING_READ,
 * @ref GLOBUS_XIO_GRIDFTP_ERROR_PENDING_WRITE,
 * @ref GLOBUS_XIO_GRIDFTP_ERROR_OUTSTANDING_PARTIAL_XFER
 *
 * @see globus_xio_driver_error_match()
 * @see globus_error_errno_match()
 */

/**
 * GridFTP driver specific error types
 * @ingroup globus_xio_gridftp_driver
 */
typedef enum
{
    /**
     * Indicates that an error occurred in the attribute control
     */
    GLOBUS_XIO_GRIDFTP_ERROR_ATTR,
    /**
     * Indicates that a seek has been called while there is an outstanding I/O
     */
    GLOBUS_XIO_GRIDFTP_ERROR_SEEK,
    /**
     * Indicates that a write has been called while there is an outstanding
     * read
     */
    GLOBUS_XIO_GRIDFTP_ERROR_OUTSTANDING_READ,
    /**
     * Indicates that a read has been called while there is an outstanding
     * write
     */
    GLOBUS_XIO_GRIDFTP_ERROR_OUTSTANDING_WRITE,
    /**
     * Indicates that a write has been called while there is a read pending
     */
    GLOBUS_XIO_GRIDFTP_ERROR_PENDING_READ,
    /**
     * Indicates that a read has been called while there is a write pending
     */
    GLOBUS_XIO_GRIDFTP_ERROR_PENDING_WRITE,
    /**
     * Indicates that a second partial xfer has been initiated while the first
     * one is still outstanding
     */
    GLOBUS_XIO_GRIDFTP_ERROR_OUTSTANDING_PARTIAL_XFER

} globus_xio_gridftp_error_type_t;

#define globus_xio_gridftp_attr_cntl globus_xio_attr_cntl
#define globus_xio_gridftp_handle_cntl globus_xio_handle_cntl

/** doxygen varargs filter stuff
 * GlobusVarArgDefine(
 *      attr, globus_result_t, globus_xio_gridftp_attr_cntl, attr, driver)
 * GlobusVarArgDefine(
 *      handle, globus_result_t, globus_xio_gridftp_handle_cntl, handle, driver)
 */

/**
 * GRIDFTP driver specific cntls
 * @ingroup globus_xio_gridftp_driver
 */

typedef enum
{
    /*
     * handle cntls
     */

    /** GlobusVarArgEnum(handle)
     * Reposition the offset of the file being read/written.
     * @ingroup gridftp_driver_cntls
     *
     * @param seek_offset
     *      Specifies the desired offset.
     */
    /* globus_off_t			seek_offset */
    GLOBUS_XIO_GRIDFTP_SEEK,

    /*
     * attr cntls
     */
    /** GlobusVarArgEnum(attr)
     * Set the ftp client handle to use.
     * @ingroup gridftp_driver_cntls
     * Do not create a new ftp client handle, use this handle instead.
     *
     * @param ftp_handle
     *      Specifies the pointer to globus ftp client handle.
     *      Note: this handle will not be destroyed.
     */
    /* globus_ftp_client_handle_t *	ftp_handle */
    GLOBUS_XIO_GRIDFTP_SET_HANDLE,

    /** GlobusVarArgEnum(attr)
     * Get the ftp client handle on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param ftp_handle_out
     *      The ftp client handle pointer will be stored here. If none is set,
     *      NULL will be set.
     */
    /* globus_ftp_client_handle_t **	ftp_handle_out */
    GLOBUS_XIO_GRIDFTP_GET_HANDLE,

    /** GlobusVarArgEnum(attr)
     * Enable or disable opening the file in append mode.
     * @ingroup gridftp_driver_cntls
     *
     * @param append
     *      GLOBUS_TRUE to enable, GLOBUS_FALSE to disable (default).
     */
    /* globus_bool_t			append */
    GLOBUS_XIO_GRIDFTP_SET_APPEND,

    /** GlobusVarArgEnum(attr)
     * Get the append flag on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param append_out
     *	    The append flag will be stored here.
     */
    /* globus_bool_t *			append_out */
    GLOBUS_XIO_GRIDFTP_GET_APPEND,

    /** GlobusVarArgEnum(attr)
     * Set the ERET algorithm string. This string contains information needed
     * to invoke a server-specific data reduction algorithm on the file being
     * retrieved.
     * @ingroup gridftp_driver_cntls
     *
     * @param eret_alg_str
     *      Specifies the ERET algorithm string.
     */
    /* const char *			eret_alg_str */
    GLOBUS_XIO_GRIDFTP_SET_ERET,

    /** GlobusVarArgEnum(attr)
     * Get the ERET algorithm string.
     * @ingroup gridftp_driver_cntls
     *
     * @param eret_alg_str_out
     *      The ERET algorithm string will be stored here. It is the
     * responsibility of the user to free the memory allocated for this string.
     */
    /* char **				eret_alg_str_out */
    GLOBUS_XIO_GRIDFTP_GET_ERET,

    /** GlobusVarArgEnum(attr)
     * Set the ESTO algorithm string. This string contains information needed
     * to invoke a server-specific data reduction algorithm on the file being
     * stored.
     * @ingroup gridftp_driver_cntls
     *
     * @param esto_alg_str
     *      Specifies the ESTO algorithm string.
     */
    /* const char *			esto_alg_str */
    GLOBUS_XIO_GRIDFTP_SET_ESTO,

    /** GlobusVarArgEnum(attr)
     * Get the ESTO algorithm string.
     * @ingroup gridftp_driver_cntls
     *
     * @param esto_alg_str_out
     *      The ESTO algorithm string will be stored here. It is the
     * responsibility of the user to free the memory allocated for this string.
     */
    /* char **				esto_alg_str_out */
    GLOBUS_XIO_GRIDFTP_GET_ESTO,

    /** GlobusVarArgEnum(attr)
     * Enable or disable partial transfer (associate a transfer with each
     * read/write) on the GridFTP handle.
     * @ingroup gridftp_driver_cntls
     *
     * @param partial_xfer
     *      GLOBUS_TRUE to enable, GLOBUS_FALSE to disable (default).
     */
    /* globus_bool_t			partial_xfer */
    GLOBUS_XIO_GRIDFTP_SET_PARTIAL_TRANSFER,

    /** GlobusVarArgEnum(attr)
     * Get the partial transfer flag on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param partial_xfer_out
     *      The partial xfer flag will be stored here.
     */
    /* globus_bool_t *			partial_xfer_out */
    GLOBUS_XIO_GRIDFTP_GET_PARTIAL_TRANSFER,

    /** GlobusVarArgEnum(attr)
     * Set the number of TCP streams to be used between the client and the
     * server.
     * @ingroup gridftp_driver_cntls
     *
     * @param num_streams
     *      Specifies the number of streams to use.
     */
    /* int				num_streams */
    GLOBUS_XIO_GRIDFTP_SET_NUM_STREAMS,

    /** GlobusVarArgEnum(attr)
     * Get the number of TCP streams on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param num_streams_out
     *      The stream count will be stored here.
     */
    /* int *				num_streams_out */
    GLOBUS_XIO_GRIDFTP_GET_NUM_STREAMS,

    /** GlobusVarArgEnum(attr)
     * Set the TCP socket send/recv buffer size.
     * @ingroup gridftp_driver_cntls
     *
     * @param buf_size
     *      The send/recv buffer size in bytes to use. (default is system
     *      specific)
     */
    /* int				buf_size */
    GLOBUS_XIO_GRIDFTP_SET_TCP_BUFFER,

    /** GlobusVarArgEnum(attr)
     * Get the TCP socket send/recv buffer size on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param buf_size_out
     *      The send/recv buffer size will be stored here.
     */
    /* int *				buf_size_out */
    GLOBUS_XIO_GRIDFTP_GET_TCP_BUFFER,

    /** GlobusVarArgEnum(attr)
     * Set the transmission mode used for data transfer
     * @ingroup gridftp_driver_cntls
     *
     * @param mode
     *      Specifies the data transmission mode. (default is stream mode)
     *
     * @see globus_l_xio_gridftp_mode_t
     */
    /* int				mode */
    GLOBUS_XIO_GRIDFTP_SET_MODE,

    /** GlobusVarArgEnum(attr)
     * Get the data transmission mode on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param mode_out
     *      The data transmission mode will be stored here.
     *
     * @see globus_l_xio_gridftp_mode_t
     */
    /* int *				mode_out */
    GLOBUS_XIO_GRIDFTP_GET_MODE,

    /** GlobusVarArgEnum(attr)
     * Set the authentication information used to authenticate with the GridFTP
     * server
     * @ingroup gridftp_driver_cntls
     *
     * @param credential
     *      The credential to use for authenticating with a GridFTP server.
     *      This may be GSS_C_NO_CREDENTIAL to use the default credential.
     * @param user
     *      The user name to send to the GridFTP server. When doing a GSI
     *      transfer, this may be set to NULL, and the default gridmap entry
     *      for the user's GSI identity will be used
     * @param password
     *      The password to send to the GridFTP server. When doing a GSI
     *      transfer, this may be set to NULL.
     * @param account
     *      The account to use for the data transfer.
     * @param subject
     *      The subject name of the GridFTP server. This is only used when
     *      doing a GSI transfer, and then only when the security subject
     *      name does not match the hostname of the server (ie, when the server
     *      is being run by a user).
     */
    /* gss_cred_id_t			credential,
     * const char *			user,
     * const char *			password,
     * const char *			account,
     * const char *			subject */
    GLOBUS_XIO_GRIDFTP_SET_AUTH,

    /** GlobusVarArgEnum(attr)
     * Get the authentication information on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param credential_out
     *      The credential will be stored here.
     * @param user_out
     *      The user name will be stored here.
     * @param password_out
     *      The password will be stored here.
     * @param account_out
     *      The account information will be stored here.
     * @param subject_out
     *      The subject name will be stored here.
     */
    /* gss_cred_id_t *			credential_out,
     * const char **                    user_out,
     * const char **                    password_out,
     * const char **                    account_out,
     * const char **                    subject_out */
    GLOBUS_XIO_GRIDFTP_GET_AUTH,

    /** GlobusVarArgEnum(attr)
     * Set the mode of authentication to be performed on GridFTP data channels.
     * @ingroup gridftp_driver_cntls
     *
     * @param dcau_mode
     *      Specifies the authentication mode.
     *
     * @see globus_l_xio_gridftp_dcau_mode_t
     */
    /* int				dcau_mode */
    GLOBUS_XIO_GRIDFTP_SET_DCAU,

    /** GlobusVarArgEnum(attr)
     * Get the data channel authentication mode on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param dcau_mode_out
     *      The data channel authentication mode will be stored here.
     *
     * @see globus_l_xio_gridftp_dcau_mode_t
     */
    /* int *				dcau_mode_out */
    GLOBUS_XIO_GRIDFTP_GET_DCAU,

    /** GlobusVarArgEnum(attr)
     * Set protection level on the data channel.
     * @ingroup gridftp_driver_cntls
     *
     * @param protection
     *      Specifies the protection level.
     *
     * @see globus_l_xio_gridftp_protection_t
     */
    /* int				protection */
    GLOBUS_XIO_GRIDFTP_SET_DATA_PROTECTION,

    /** GlobusVarArgEnum(attr)
     * Get the data channel protection level on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param protection_out
     *      The data channel protection level will be stored here.
     *
     * @see globus_l_xio_gridftp_dcau_mode_t
     */
    /* int *				protection_out */
    GLOBUS_XIO_GRIDFTP_GET_DATA_PROTECTION,

    /** GlobusVarArgEnum(attr)
     * Set protection level on the control channel.
     * @ingroup gridftp_driver_cntls
     *
     * @param protection
     *      Specifies the protection level.
     *
     * @see globus_l_xio_gridftp_protection_t
     */
    /* int				protection */
    GLOBUS_XIO_GRIDFTP_SET_CONTROL_PROTECTION,

    /** GlobusVarArgEnum(attr)
     * Get the control channel protection level on the attr.
     * @ingroup gridftp_driver_cntls
     *
     * @param protection_out
     *      The control channel protection level will be stored here.
     *
     * @see globus_l_xio_gridftp_protection_t
     */
    /* int *				protection_out */
    GLOBUS_XIO_GRIDFTP_GET_CONTROL_PROTECTION

} globus_xio_gridftp_cmd_t;

/**
 * GRIDFTP driver specific types
 * @ingroup globus_xio_gridftp_driver
 * @hideinitializer
 */

typedef enum globus_l_xio_gridftp_mode_e
{
    GLOBUS_XIO_GRIDFTP_MODE_NONE,
    GLOBUS_XIO_GRIDFTP_MODE_STREAM = 'S',
    GLOBUS_XIO_GRIDFTP_MODE_BLOCK = 'B',
    GLOBUS_XIO_GRIDFTP_MODE_EXTENDED_BLOCK = 'E',
    GLOBUS_XIO_GRIDFTP_MODE_COMPRESSED = 'C'
} globus_l_xio_gridftp_mode_t;

typedef enum globus_l_xio_gridftp_dcau_mode_e
{
    GLOBUS_XIO_GRIDFTP_DCAU_NONE = 'N',
    GLOBUS_XIO_GRIDFTP_DCAU_SELF = 'A',
    GLOBUS_XIO_GRIDFTP_DCAU_SUBJECT = 'S',
    GLOBUS_XIO_GRIDFTP_DCAU_DEFAULT
} globus_l_xio_gridftp_dcau_mode_t;

typedef enum globus_l_xio_gridftp_protection_e
{
    GLOBUS_XIO_GRIDFTP_PROTECTION_CLEAR = 'C',
    GLOBUS_XIO_GRIDFTP_PROTECTION_SAFE = 'S',
    GLOBUS_XIO_GRIDFTP_PROTECTION_CONFIDENTIAL = 'E',
    GLOBUS_XIO_GRIDFTP_PROTECTION_PRIVATE = 'P'
} globus_l_xio_gridftp_protection_t;

#endif /* GLOBUS_XIO_GRIDFTP_DRIVER_H */


text:
{% load request_tags %}
{% load thread_tags %}
{% with vote_count=vote_count_request|count_votes %}
{{ vote_count_request.owner|display_user:user }}

     0 %}href="#"
        data-toggle="dropdown" title="Show Votes"{% endif %}>+{{ vote_count }}

    {% for voter in vote_count_request.upvotes.all %}

{{ voter|display_user:user }}

    {% endfor %}

{% endwith %}
({{ vote_count_request.post_date }}):


text:
<?php

namespace Drupal\rp_stream_provider;

use Drupal\Core\Entity\ContentEntityStorageInterface;
use Drupal\Core\Session\AccountInterface;
use Drupal\Core\Language\LanguageInterface;
use Drupal\rp_stream_provider\Entity\StreamProviderInterface;

/**
 * Defines the storage handler class for Stream Provider entities.
 *
 * This extends the base storage class, adding required special handling for
 * Stream Provider entities.
 *
 * @ingroup rp_stream_provider
 */
interface StreamProviderStorageInterface extends ContentEntityStorageInterface {

  /**
   * Gets a list of Stream Provider revision IDs for a specific Stream Provider.
   *
   * @param \Drupal\rp_stream_provider\Entity\StreamProviderInterface $entity
   *   The Stream Provider entity.
   *
   * @return int[]
   *   Stream Provider revision IDs (in ascending order).
   */
  public function revisionIds(StreamProviderInterface $entity);

  /**
   * Gets a list of revision IDs having a given user as Stream Provider author.
   *
   * @param \Drupal\Core\Session\AccountInterface $account
   *   The user entity.
   *
   * @return int[]
   *   Stream Provider revision IDs (in ascending order).
   */
  public function userRevisionIds(AccountInterface $account);

  /**
   * Counts the number of revisions in the default language.
   *
   * @param \Drupal\rp_stream_provider\Entity\StreamProviderInterface $entity
   *   The Stream Provider entity.
   *
   * @return int
   *   The number of revisions in the default language.
   */
  public function countDefaultLanguageRevisions(StreamProviderInterface $entity);

  /**
   * Unsets the language for all Stream Provider with the given language.
   *
   * @param \Drupal\Core\Language\LanguageInterface $language
   *   The language object.
   */
  public function clearRevisionsLanguage(LanguageInterface $language);

}


text:
package static

//go:generate go-bindata --fs --ignore ".*.go" --pkg static --prefix "static/" .


text:
      <a class="brand" href="<?php echo home_url(); ?>/">
        <?php bloginfo('name'); ?>

        <?php
          if (has_nav_menu('primary_navigation')) :
            wp_nav_menu(array('theme_location' => 'primary_navigation', 'menu_class' => 'nav'));
          endif;
        ?>


text:
using System;
using System.Collections.Generic;

namespace Mozu.Api.Urls.Platform
{
	public partial class ReferenceDataUrl
	{

		/// <summary>
        /// Get Resource Url for GetAddressSchema
        /// </summary>
        /// <param name="countryCode">The 2-letter geographic code representing the country for the physical or mailing address. Currently limited to the US.</param>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetAddressSchemaUrl(string countryCode =  null, string responseFields =  null)
		{
			var url = "/api/platform/reference/addressschema/{countryCode}?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "countryCode", countryCode);
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetAddressSchemas
        /// </summary>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetAddressSchemasUrl(string responseFields =  null)
		{
			var url = "/api/platform/reference/addressschemas?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetBehavior
        /// </summary>
        /// <param name="behaviorId">Unique identifier of the behavior.</param>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetBehaviorUrl(int behaviorId, string responseFields =  null)
		{
			var url = "/api/platform/reference/behaviors/{behaviorId}?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "behaviorId", behaviorId);
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetBehaviorCategory
        /// </summary>
        /// <param name="categoryId">Unique identifier of the category to modify.</param>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetBehaviorCategoryUrl(int categoryId, string responseFields =  null)
		{
			var url = "/api/platform/reference/behaviors/categories/{categoryId}?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "categoryId", categoryId);
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetBehaviorCategories
        /// </summary>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetBehaviorCategoriesUrl(string responseFields =  null)
		{
			var url = "/api/platform/reference/behaviors/categories?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetBehaviors
        /// </summary>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <param name="userType">The user type associated with the behaviors to retrieve.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetBehaviorsUrl(string userType =  null, string responseFields =  null)
		{
			var url = "/api/platform/reference/behaviors?userType={userType}&responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "responseFields", responseFields);
			mozuUrl.FormatUrl( "userType", userType);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetContentLocales
        /// </summary>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetContentLocalesUrl(string responseFields =  null)
		{
			var url = "/api/platform/reference/contentLocales?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetCountries
        /// </summary>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetCountriesUrl(string responseFields =  null)
		{
			var url = "/api/platform/reference/countries?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetCountriesWithStates
        /// </summary>
        /// <param name="responseFields">A list or array of fields returned for a call. These fields may be customized and may be used for various types of data calls in Mozu. For example, responseFields are returned for retrieving or updating attributes, carts, and messages in Mozu.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetCountriesWithStatesUrl(string responseFields =  null)
		{
			var url = "/api/platform/reference/countrieswithstates?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetCurrencies
        /// </summary>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetCurrenciesUrl(string responseFields =  null)
		{
			var url = "/api/platform/reference/currencies?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetTimeZones
        /// </summary>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetTimeZonesUrl(string responseFields =  null)
		{
			var url = "/api/platform/reference/timezones?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetTopLevelDomains
        /// </summary>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetTopLevelDomainsUrl(string responseFields =  null)
		{
			var url = "/api/platform/reference/topleveldomains?responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

		/// <summary>
        /// Get Resource Url for GetUnitsOfMeasure
        /// </summary>
        /// <param name="filter">A set of expressions that consist of a field, operator, and value and represent search parameter syntax when filtering results of a query. Valid operators include equals (eq), does not equal (ne), greater than (gt), less than (lt), greater than or equal to (ge), less than or equal to (le), starts with (sw), or contains (cont). For example - "filter=IsDisplayed+eq+true"</param>
        /// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
        /// <returns>
        /// String - Resource Url
        /// </returns>
        public static MozuUrl GetUnitsOfMeasureUrl(string filter =  null, string responseFields =  null)
		{
			var url = "/api/platform/reference/unitsofmeasure?filter={filter}&responseFields={responseFields}";
			var mozuUrl = new MozuUrl(url, MozuUrl.UrlLocation.HOME_POD, false) ;
			mozuUrl.FormatUrl( "filter", filter);
			mozuUrl.FormatUrl( "responseFields", responseFields);
			return mozuUrl;
		}

	}
}


text:
package supersnake.game.actor;

import supersnake.input.Key;
import supersnake.input.KeyManager;
import supersnake.game.object.Snake;
import supersnake.util.Direction;
import supersnake.util.Time;
import supersnake.Skins;

public class Player extends Actor{
  public Player(){
    this(0, 0, 1, Direction.UP);
  }

  public Player(int x, int y, int length, Direction direction){
    super(new Snake(x, y, length, direction));
    Snake snake = (Snake) object;
    snake.setActor(this);
    snake.setSkin(Skins.SNAKE_RAINBOW);
    snake.setUpdateDelay(Time.SECOND / 10.0);
  }

  @Override
  public void update(double timeElapsed){
    Snake snake = (Snake) object;
    if(KeyManager.isPressed(Key.UP) && snake.getDirection() != Direction.DOWN){
      snake.setDirection(Direction.UP);
    }
    else if(KeyManager.isPressed(Key.RIGHT) && snake.getDirection() != Direction.LEFT){
      snake.setDirection(Direction.RIGHT);
    }
    else if(KeyManager.isPressed(Key.DOWN) && snake.getDirection() != Direction.UP){
      snake.setDirection(Direction.DOWN);
    }
    else if(KeyManager.isPressed(Key.LEFT) && snake.getDirection() != Direction.RIGHT){
      snake.setDirection(Direction.LEFT);
    }
    if(KeyManager.isPressed(Key.SPACE)){
      activateItem();
    }
    super.update(timeElapsed);
  }
}


text:
class ResultsFileNotifierPreview < ActionMailer::Preview

  def file_uploaded
    file = FactoryBot.build(
      :stored_file,
      :results,
      creator: User.first,
      order_detail: OrderDetail.first
    )

    ResultsFileNotifierMailer.file_uploaded(file)
  end

end


text:
<?php
define('BATCH_SIZE', 1000);

// USERS AND GROUPS (first value in array is the default)
define('SMF_USER_GROUPS_IDS', serialize(array(2, 4, 8)));
define('OW_USER_GROUPS_IDS', serialize(array(10, 11, 12)));

// FORUMS
define('SMF_FORUM_IDS', serialize(array(1)));
define('OW_FORUM_IDS', serialize(array(8)));

// DATABASES
define('MIGRATION_HELPER_DB_HOST', '127.0.0.1');
define('MIGRATION_HELPER_DB_USER', 'root');
define('MIGRATION_HELPER_DB_PASSWORD', '');
define('MIGRATION_HELPER_DB_SCHEMA', 'migration_helper');
define('MIGRATION_HELPER_DB_TABLE_PREFIX', 'mgr8');

define('SMF_DB_HOST', '127.0.0.1');
define('SMF_DB_USER', 'root');
define('SMF_DB_PASSWORD', '');
define('SMF_DB_SCHEMA', 'old_smf');

// PATHS
define('_OW_', true);
define('DS', DIRECTORY_SEPARATOR);
define('DIR_ROOT', dirname(__FILE__) . DS);
define('OW_DIR_ROOT', dirname(__FILE__) . DS . 'oxwall' . DS);

define('SMF_ATTACHMENT_FOLDERS', serialize(array("/var/folder_1", "/var/folder_2", "/var/folder_3")));

define('OW_SMILEYS_BASE_URL', "http://example.com/ow_userfiles/plugins/smileys/smileys/");


text:
  Drulingen est
      une commune localisée dans le département de Bas-Rhin en Alsace. Elle totalisait 1 453 habitants en 2008.

La ville compte quelques  équipements, elle propose entre autres un terrain de tennis, un terrain de sport et une salle de combat.

À Drulingen, la valeur moyenne à l'achat d'un appartement s'évalue à 1 468 € du m² en vente. la valorisation moyenne d'une maison à l'achat se situe à 405 € du m². À la location le prix moyen se situe à 8,97 € du m² par mois.

La ville dispose concernant la formation de un collège.
S'agissant les plus jeunes, la ville dispose de une maternelle et une école primaire.
Drulingen propose les installations facilitant une bonne prise en charge des jeunes.
Si vous avez un projet d'achat immobilier à Drulingen, il est important regarder la notoriété des équipements éducatifs

À proximité de Drulingen sont situées les villes de
Weyer située à 2 km, 545 habitants,
Lohr localisée à 3 km, 512 habitants,
Gungwiller située à 2 km, 297 habitants,
Bettwiller localisée à 2 km, 337 habitants,
Siewiller localisée à 2 km, 411 habitants,
Asswiller localisée à 2 km, 264 habitants,
 entre autres. De plus, Drulingen est située à seulement 28 km de Sarreguemines.

Le parc de logements, à Drulingen, était réparti en 2011 en 209 appartements et 401 maisons soit
 un marché relativement équilibré.


text:
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file includes all the necessary GL headers and implements some useful
// utilities.

#ifndef GPU_COMMAND_BUFFER_SERVICE_GL_UTILS_H_
#define GPU_COMMAND_BUFFER_SERVICE_GL_UTILS_H_

#include "build/build_config.h"
#include "ui/gl/gl_bindings.h"

// GLES2 defines not part of Desktop GL
// Shader Precision-Specified Types
#define GL_LOW_FLOAT                      0x8DF0
#define GL_MEDIUM_FLOAT                   0x8DF1
#define GL_HIGH_FLOAT                     0x8DF2
#define GL_LOW_INT                        0x8DF3
#define GL_MEDIUM_INT                     0x8DF4
#define GL_HIGH_INT                       0x8DF5
#define GL_IMPLEMENTATION_COLOR_READ_TYPE   0x8B9A
#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
#define GL_MAX_FRAGMENT_UNIFORM_VECTORS     0x8DFD
#define GL_MAX_VERTEX_UNIFORM_VECTORS       0x8DFB
#define GL_MAX_VARYING_VECTORS              0x8DFC
#define GL_SHADER_BINARY_FORMATS          0x8DF8
#define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9
#define GL_SHADER_COMPILER                0x8DFA
#define GL_RGB565                         0x8D62
#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES 0x8B8B
#define GL_RGB8_OES                            0x8051
#define GL_RGBA8_OES                           0x8058
#define GL_HALF_FLOAT_OES                      0x8D61

// GL_OES_EGL_image_external
#define GL_TEXTURE_EXTERNAL_OES                0x8D65
#define GL_SAMPLER_EXTERNAL_OES                0x8D66
#define GL_TEXTURE_BINDING_EXTERNAL_OES        0x8D67
#define GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES    0x8D68

// GL_ANGLE_translated_shader_source
#define GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE 0x93A0

// GL_CHROMIUM_flipy
#define GL_UNPACK_FLIP_Y_CHROMIUM             0x9240

#define GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM     0x9241
#define GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM   0x9242
#define GL_UNPACK_COLORSPACE_CONVERSION_CHROMIUM 0x9243

// GL_ANGLE_pack_reverse_row_order
#define GL_PACK_REVERSE_ROW_ORDER_ANGLE    0x93A4

// GL_ANGLE_texture_usage
#define GL_TEXTURE_USAGE_ANGLE                 0x93A2
#define GL_FRAMEBUFFER_ATTACHMENT_ANGLE        0x93A3

// GL_EXT_texture_storage
#define GL_TEXTURE_IMMUTABLE_FORMAT_EXT        0x912F
#define GL_ALPHA8_EXT                          0x803C
#define GL_LUMINANCE8_EXT                      0x8040
#define GL_LUMINANCE8_ALPHA8_EXT               0x8045
#define GL_RGBA32F_EXT                         0x8814
#define GL_RGB32F_EXT                          0x8815
#define GL_ALPHA32F_EXT                        0x8816
#define GL_LUMINANCE32F_EXT                    0x8818
#define GL_LUMINANCE_ALPHA32F_EXT              0x8819
#define GL_RGBA16F_EXT                         0x881A
#define GL_RGB16F_EXT                          0x881B
#define GL_ALPHA16F_EXT                        0x881C
#define GL_LUMINANCE16F_EXT                    0x881E
#define GL_LUMINANCE_ALPHA16F_EXT              0x881F
#define GL_BGRA8_EXT                           0x93A1

// GL_ANGLE_instanced_arrays
#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE   0x88FE

// GL_EXT_occlusion_query_boolean
#define GL_ANY_SAMPLES_PASSED_EXT              0x8C2F
#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT 0x8D6A
#define GL_CURRENT_QUERY_EXT                   0x8865
#define GL_QUERY_RESULT_EXT                    0x8866
#define GL_QUERY_RESULT_AVAILABLE_EXT          0x8867

// GL_CHROMIUM_command_buffer_query
#define GL_COMMANDS_ISSUED_CHROMIUM            0x84F2

/* GL_CHROMIUM_get_error_query */
#define GL_GET_ERROR_QUERY_CHROMIUM            0x84F3

// GL_OES_texure_3D
#define GL_SAMPLER_3D_OES                      0x8B5F

// GL_OES_depth24
#define GL_DEPTH_COMPONENT24_OES               0x81A6

// GL_OES_depth32
#define GL_DEPTH_COMPONENT32_OES               0x81A7

// GL_OES_packed_depth_stencil
#define GL_DEPTH24_STENCIL8_OES                0x88F0

#define GL_GLEXT_PROTOTYPES 1

// Define this for extra GL error debugging (slower).
// #define GL_ERROR_DEBUGGING
#ifdef GL_ERROR_DEBUGGING
#define CHECK_GL_ERROR() do {                                           \
    GLenum gl_error = glGetError();                                     \
    LOG_IF(ERROR, gl_error != GL_NO_ERROR) << "GL Error :" << gl_error; \
  } while (0)
#else  // GL_ERROR_DEBUGGING
#define CHECK_GL_ERROR() void(0)
#endif  // GL_ERROR_DEBUGGING

#endif  // GPU_COMMAND_BUFFER_SERVICE_GL_UTILS_H_


text:
namespace System.Configuration {
    using System;
    using System.Collections.Specialized;
    using System.Configuration.Internal;
    using System.IO;
    using System.Reflection;
    using System.Security;
    using System.Text;
    using System.Xml;
    using System.Globalization;

    public sealed class SectionInformation {
        // Flags
        private const int Flag_Attached                     = 0x00000001;
        private const int Flag_Declared                     = 0x00000002;
        private const int Flag_DeclarationRequired          = 0x00000004;
        private const int Flag_AllowLocation                = 0x00000008;
        private const int Flag_RestartOnExternalChanges     = 0x00000010;
        private const int Flag_RequirePermission            = 0x00000020;
        private const int Flag_LocationLocked               = 0x00000040;
        private const int Flag_ChildrenLocked               = 0x00000080;
        private const int Flag_InheritInChildApps           = 0x00000100;
        private const int Flag_IsParentSection              = 0x00000200;
        private const int Flag_Removed                      = 0x00000400;
        private const int Flag_ProtectionProviderDetermined = 0x00000800;
        private const int Flag_ForceSave                    = 0x00001000;
        private const int Flag_IsUndeclared                 = 0x00002000;
        private const int Flag_ChildrenLockWithoutFileInput         = 0x00004000;

        private const int Flag_AllowExeDefinitionModified   = 0x00010000;
        private const int Flag_AllowDefinitionModified      = 0x00020000;
        private const int Flag_ConfigSourceModified         = 0x00040000;
        private const int Flag_ProtectionProviderModified   = 0x00080000;
        private const int Flag_OverrideModeDefaultModified  = 0x00100000;
        private const int Flag_OverrideModeModified         = 0x00200000;   // Used only for modified tracking

        private ConfigurationSection            _configurationSection;
        private SafeBitVector32                 _flags;
        private SimpleBitVector32               _modifiedFlags;
        private ConfigurationAllowDefinition    _allowDefinition;
        private ConfigurationAllowExeDefinition _allowExeDefinition;
        private MgmtConfigurationRecord         _configRecord;
        private string                          _configKey;
        private string                          _group;
        private string                          _name;
        private string                          _typeName;
        private string                          _rawXml;
        private string                          _configSource;
        private string                          _configSourceStreamName;
        private ProtectedConfigurationProvider  _protectionProvider;
        private string                          _protectionProviderName;
        private OverrideModeSetting             _overrideModeDefault;       // The default mode for the section in _configurationSection
        private OverrideModeSetting             _overrideMode;              // The override mode at the current config path

        //
        // Constructor
        //
        internal SectionInformation(ConfigurationSection associatedConfigurationSection) {
            _configKey = String.Empty;
            _group = String.Empty;
            _name = String.Empty;

            _configurationSection   = associatedConfigurationSection;
            _allowDefinition        = ConfigurationAllowDefinition.Everywhere;
            _allowExeDefinition     = ConfigurationAllowExeDefinition.MachineToApplication;
            _overrideModeDefault    = OverrideModeSetting.SectionDefault;
            _overrideMode           = OverrideModeSetting.LocationDefault;

            _flags[ Flag_AllowLocation            ] = true;
            _flags[ Flag_RestartOnExternalChanges ] = true;
            _flags[ Flag_RequirePermission        ] = true;
            _flags[ Flag_InheritInChildApps       ] = true;
            _flags[ Flag_ForceSave                ] = false;

            _modifiedFlags = new SimpleBitVector32();
        }

        internal void ResetModifiedFlags() {
            _modifiedFlags = new SimpleBitVector32();
        }

        internal bool IsModifiedFlags() {
            return (_modifiedFlags.Data != 0);
        }
        // for instantiation of a ConfigurationSection from GetConfig
        internal void AttachToConfigurationRecord(MgmtConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) {
            SetRuntimeConfigurationInformation(configRecord, factoryRecord, sectionRecord);
            _configRecord = configRecord;
        }

        internal void SetRuntimeConfigurationInformation(BaseConfigurationRecord configRecord, FactoryRecord factoryRecord, SectionRecord sectionRecord) {
            _flags[ Flag_Attached ] = true;

            // factory info
            _configKey          = factoryRecord.ConfigKey;
            _group              = factoryRecord.Group;
            _name               = factoryRecord.Name;
            _typeName           = factoryRecord.FactoryTypeName;
            _allowDefinition    = factoryRecord.AllowDefinition;
            _allowExeDefinition = factoryRecord.AllowExeDefinition;
            _flags[ Flag_AllowLocation            ] = factoryRecord.AllowLocation;
            _flags[ Flag_RestartOnExternalChanges ] = factoryRecord.RestartOnExternalChanges;
            _flags[ Flag_RequirePermission        ] = factoryRecord.RequirePermission;
            _overrideModeDefault                    = factoryRecord.OverrideModeDefault;

            if (factoryRecord.IsUndeclared) {
                _flags[ Flag_IsUndeclared             ] = true;
                _flags[ Flag_Declared                 ] = false;
                _flags[ Flag_DeclarationRequired      ] = false;
            }
            else {
                _flags[ Flag_IsUndeclared             ] = false;
                _flags[ Flag_Declared                 ] = configRecord.GetFactoryRecord(factoryRecord.ConfigKey, false) != null;
                _flags[ Flag_DeclarationRequired      ] = configRecord.IsRootDeclaration(factoryRecord.ConfigKey, false);
            }

            // section info
            _flags[ Flag_LocationLocked ]               = sectionRecord.Locked;
            _flags[ Flag_ChildrenLocked ]               = sectionRecord.LockChildren;
            _flags[ Flag_ChildrenLockWithoutFileInput]  = sectionRecord.LockChildrenWithoutFileInput;

            if (sectionRecord.HasFileInput) {
                SectionInput fileInput = sectionRecord.FileInput;

                _flags[ Flag_ProtectionProviderDetermined ] = fileInput.IsProtectionProviderDetermined;
                _protectionProvider                         = fileInput.ProtectionProvider;

                SectionXmlInfo sectionXmlInfo = fileInput.SectionXmlInfo;

                _configSource                       = sectionXmlInfo.ConfigSource;
                _configSourceStreamName             = sectionXmlInfo.ConfigSourceStreamName;
                _overrideMode                       = sectionXmlInfo.OverrideModeSetting;
                _flags[ Flag_InheritInChildApps ]   = !sectionXmlInfo.SkipInChildApps;
                _protectionProviderName             = sectionXmlInfo.ProtectionProviderName;
            }
            else {
                _flags[ Flag_ProtectionProviderDetermined ] = false;
                _protectionProvider = null;
            }

            // element context information
            _configurationSection.AssociateContext( configRecord );
        }

        internal void DetachFromConfigurationRecord() {
            RevertToParent();
            _flags[ Flag_Attached ] = false;
            _configRecord = null;
        }

        private bool IsRuntime {
            get {
                return ( _flags[ Flag_Attached ] ) &&
                       ( _configRecord == null   );
            }
        }

        internal bool Attached {
            get {return _flags[ Flag_Attached ];}
        }

        private void VerifyDesigntime() {
            if (IsRuntime) {
                throw new InvalidOperationException(SR.GetString(SR.Config_operation_not_runtime));
            }
        }

        private void VerifyIsAttachedToConfigRecord() {
            if (_configRecord == null) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_not_attached));
            }
        }

        // VerifyIsEditable
        //
        // Verify the section is Editable.
        // It may not be editable for the following reasons:
        //   - We are in Runtime mode, not Design time
        //   - The section is not attached to a _configRecord.
        //   - We are locked (ie. allowOveride = false )
        //   - We are a parent section (ie. Retrieved from GetParentSection)
        //
        internal void VerifyIsEditable() {
            VerifyDesigntime();

            if (IsLocked) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_locked));
            }

            if (_flags[Flag_IsParentSection]) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_parentsection));
            }

            if ( !_flags[ Flag_AllowLocation ] &&
                 ( _configRecord != null ) &&
                 ( _configRecord.IsLocationConfig ) ) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_location_locked));
            }
        }

        // VerifyNotParentSection
        //
        // Verify that this is not a parent section
        //
        private void VerifyNotParentSection() {
            if ( _flags[Flag_IsParentSection] ) {
                throw new InvalidOperationException(SR.GetString(SR.Config_configsection_parentnotvalid));
           }
        }

        // VerifySupportsLocation
        //
        // Verify that we support the location tag.  This is true either
        // in machine.config, or in any place for the web config system
        //
        private void VerifySupportsLocation() {
            if ( ( _configRecord != null ) &&
                 !_configRecord.RecordSupportsLocation ) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_locationattriubtes));
            }
        }

        internal void VerifyIsEditableFactory() {
            if (_configRecord != null && _configRecord.IsLocationConfig) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_in_location_config));
            }

            // Can't edit factory if the section is built-in
            if (BaseConfigurationRecord.IsImplicitSection(ConfigKey)) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_it_is_implicit));
            }

            // Can't edit undeclared section
            if (_flags[Flag_IsUndeclared]) {
                throw new InvalidOperationException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_it_is_undeclared));
            }
        }

        internal string ConfigKey {
            get {return _configKey;}
        }

        internal bool Removed {
            get {
                return _flags[ Flag_Removed ];
            }
            set {
                _flags[ Flag_Removed ] = value;
            }
        }

        private FactoryRecord FindParentFactoryRecord(bool permitErrors) {
            FactoryRecord factoryRecord = null;

            if (_configRecord != null && !_configRecord.Parent.IsRootConfig) {
                factoryRecord = _configRecord.Parent.FindFactoryRecord(_configKey, permitErrors);
            }

            return factoryRecord;
        }

        //
        // public properties and methods
        //
        public string SectionName {
            get {return _configKey;}
        }

        public string Name {
            get {return _name;}
        }

        public ConfigurationAllowDefinition AllowDefinition {
            get {return _allowDefinition;}
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory();

                // allow AllowDefinition to be different from current type,
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.AllowDefinition != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }

                _allowDefinition = value;
                _modifiedFlags[ Flag_AllowDefinitionModified       ] = true;
            }
        }

        internal bool AllowDefinitionModified {
            get {
                return _modifiedFlags[ Flag_AllowDefinitionModified ];
            }
        }

        public ConfigurationAllowExeDefinition AllowExeDefinition {
            get {return _allowExeDefinition;}
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory();

                // allow AllowDefinition to be different from current type,
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.AllowExeDefinition != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }

                _allowExeDefinition = value;
                _modifiedFlags[ Flag_AllowExeDefinitionModified       ] = true;
            }
        }

        internal bool AllowExeDefinitionModified {
            get {
                return _modifiedFlags[ Flag_AllowExeDefinitionModified ];
            }
        }

        public OverrideMode OverrideModeDefault {
            get {return _overrideModeDefault.OverrideMode;}
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory();

                // allow OverrideModeDefault to be different from current value,
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.OverrideModeDefault.OverrideMode != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }

                // Threat "Inherit" as "Allow" as "Inherit" does not make sense as a default
                if (value == OverrideMode.Inherit) {
                    value = OverrideMode.Allow;
                }

                _overrideModeDefault.OverrideMode = value;
                _modifiedFlags[ Flag_OverrideModeDefaultModified       ] = true;
            }
        }

        internal OverrideModeSetting OverrideModeDefaultSetting {
            get { return _overrideModeDefault; }
        }

        internal bool OverrideModeDefaultModified {
            get {
                return _modifiedFlags[ Flag_OverrideModeDefaultModified ];
            }
        }

        public bool AllowLocation {
            get {
                return _flags[ Flag_AllowLocation ];
            }
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory();

                // allow AllowLocation to be different from current type,
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.AllowLocation != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }

                _flags[ Flag_AllowLocation ] = value;
                _modifiedFlags[ Flag_AllowLocation ] = true;
            }
        }

        internal bool AllowLocationModified {
            get {
                return _modifiedFlags[ Flag_AllowLocation ];
            }
        }

        public bool AllowOverride {
            get {
                return _overrideMode.AllowOverride;
            }
            set {
                VerifyIsEditable();
                VerifySupportsLocation();
                _overrideMode.AllowOverride = value;
                _modifiedFlags[ Flag_OverrideModeModified] = true;
            }
        }

        public OverrideMode OverrideMode {
            get {
                return _overrideMode.OverrideMode;
            }
            set {
                VerifyIsEditable();
                VerifySupportsLocation();
                _overrideMode.OverrideMode = value;
                _modifiedFlags[ Flag_OverrideModeModified] = true;

                // Modify the state of OverrideModeEffective according to the changes to the current mode
                switch(value) {
                    case OverrideMode.Inherit:
                        // Wehen the state is changing to inherit - apply the value from parent which does not
                        // include the file input lock mode
                        _flags[Flag_ChildrenLocked] = _flags[Flag_ChildrenLockWithoutFileInput];
                        break;

                    case OverrideMode.Allow:
                        _flags[Flag_ChildrenLocked] = false;
                        break;

                    case OverrideMode.Deny:
                        _flags[Flag_ChildrenLocked] = true;
                        break;

                    default:
                        Debug.Assert(false,"Unexpected value for OverrideMode");
                        break;
                }
            }
        }

        public OverrideMode OverrideModeEffective {
            get {
                return (_flags[Flag_ChildrenLocked] ? OverrideMode.Deny : OverrideMode.Allow);
            }
        }

        internal OverrideModeSetting OverrideModeSetting {
            get { return _overrideMode; }
        }

        // LocationAttributesAreDefault
        //
        // Are the location attributes for this section set to the
        // default settings?
        //
        internal bool LocationAttributesAreDefault {
            get {
                return ( _overrideMode.IsDefaultForLocationTag &&
                         ( _flags[ Flag_InheritInChildApps ] == true ) );
            }
        }

        public string ConfigSource {
            get {
               if (_configSource != null) {
                   return _configSource;
               }
               else {
                   return String.Empty;
               }
            }

            set {
                string configSource;

                VerifyIsEditable();

                if (!String.IsNullOrEmpty(value)) {
                    configSource = BaseConfigurationRecord.NormalizeConfigSource(value, null);
                }
                else {
                    configSource = null;
                }

                // return early if there is no change
                if (configSource == _configSource)
                    return;

                if (_configRecord != null) {
                    _configRecord.ChangeConfigSource(this, _configSource, _configSourceStreamName, configSource);
                }

                _configSource = configSource;
                _modifiedFlags[Flag_ConfigSourceModified] = true;
            }
        }

        internal bool ConfigSourceModified {
            get {
                return _modifiedFlags[Flag_ConfigSourceModified];
            }
        }

        internal string ConfigSourceStreamName {
            get {
                return _configSourceStreamName;
            }

            set {
                _configSourceStreamName = value;
            }
        }

        public bool InheritInChildApplications {
            get {
                return _flags[ Flag_InheritInChildApps ];
            }
            set {
                VerifyIsEditable();
                VerifySupportsLocation();
                _flags[ Flag_InheritInChildApps ] = value;
            }
        }

        // True if the section is declared at the current level
        public bool IsDeclared {
            get {
                VerifyNotParentSection();

                return _flags[ Flag_Declared ];
            }
        }

        // IsDeclarationRequired
        //
        // Is the Declaration Required.  It is required if it is not set
        // in a parent, or the parent entry does not have the type
        //
        public bool IsDeclarationRequired {
            get {
                VerifyNotParentSection();

                return _flags[Flag_DeclarationRequired];
            }
        }

        // Force the section declaration to be written out during Save.
        public void ForceDeclaration() {
            ForceDeclaration( true );
        }

        // If force==false, it actually means don't declare it at
        // the current level.
        public void ForceDeclaration(bool force) {
            VerifyIsEditable();

            if ( ( force == false ) &&
                 _flags[ Flag_DeclarationRequired ] )
            {
                // Since it is required, we can not remove it
            }
            else
            {
                //
                //

                if (force == true && BaseConfigurationRecord.IsImplicitSection(SectionName)) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Cannot_declare_or_remove_implicit_section));
                }

                if (force == true && _flags[ Flag_IsUndeclared ] ) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_cannot_edit_configurationsection_when_it_is_undeclared));
                }

                _flags[ Flag_Declared ] = force;
            }
        }

        // IsDefinitionAllowed
        //
        // Is the Definition Allowed at this point.  This is all depending
        // on the Definition that is allowed, and what context we are
        // writing the file
        //
        private bool IsDefinitionAllowed {
            get {
                if (_configRecord == null) {
                    return true;
                }
                else {
                    return _configRecord.IsDefinitionAllowed(_allowDefinition, _allowExeDefinition);
                }
            }
        }

        public bool IsLocked {
            get {
                return _flags[Flag_LocationLocked] || !IsDefinitionAllowed ||
                    _configurationSection.ElementInformation.IsLocked;  // See VSWhidbey 484189
            }
        }

        public bool IsProtected {
            get {return (ProtectionProvider != null);}
        }

        public ProtectedConfigurationProvider ProtectionProvider {
            get {
                if (!_flags[ Flag_ProtectionProviderDetermined] && _configRecord != null) {
                    _protectionProvider = _configRecord.GetProtectionProviderFromName(_protectionProviderName, false);
                    _flags[ Flag_ProtectionProviderDetermined ] = true;
                }

                return _protectionProvider;
            }
        }

        // method to cause a section to be protected using the specified provider
        public void ProtectSection(string protectionProvider) {
            ProtectedConfigurationProvider protectedConfigurationProvider = null;

            VerifyIsEditable();

            // Do not encrypt sections that will be read by a native reader.
            // These sections are be marked with allowLocation=false.
            // Also, the configProtectedData section cannot be encrypted!
            if (!AllowLocation || _configKey == BaseConfigurationRecord.RESERVED_SECTION_PROTECTED_CONFIGURATION) {
                throw new InvalidOperationException(SR.GetString(SR.Config_not_allowed_to_encrypt_this_section));
            }

            if (_configRecord != null) {
                if (String.IsNullOrEmpty(protectionProvider)) {
                    protectionProvider = _configRecord.DefaultProviderName;
                }

                protectedConfigurationProvider = _configRecord.GetProtectionProviderFromName(protectionProvider, true);
            }
            else {
                throw new InvalidOperationException(SR.GetString(SR.Must_add_to_config_before_protecting_it));
            }

            _protectionProviderName = protectionProvider;
            _protectionProvider = protectedConfigurationProvider;

            _flags[ Flag_ProtectionProviderDetermined ] = true;
            _modifiedFlags[ Flag_ProtectionProviderModified ] = true;
        }

        public void UnprotectSection() {
            VerifyIsEditable();

            _protectionProvider = null;
            _protectionProviderName = null;
            _flags[ Flag_ProtectionProviderDetermined ] = true;
            _modifiedFlags[ Flag_ProtectionProviderModified ] = true;
        }

        internal string ProtectionProviderName {
            get { return _protectionProviderName; }
        }

        public bool RestartOnExternalChanges {
            get {
                return _flags[ Flag_RestartOnExternalChanges ];
            }
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory();

                // allow RestartOnExternalChanges to be different from current type,
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.RestartOnExternalChanges != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }

                _flags[ Flag_RestartOnExternalChanges ] = value;
                _modifiedFlags[ Flag_RestartOnExternalChanges ] = true;
            }
        }

        internal bool RestartOnExternalChangesModified {
            get {
                return _modifiedFlags[ Flag_RestartOnExternalChanges ];
            }
        }

        public bool RequirePermission {
            get {
                return _flags[ Flag_RequirePermission ];
            }
            set {
                VerifyIsEditable();
                VerifyIsEditableFactory();

                // allow RequirePermission to be different from current type,
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null && factoryRecord.RequirePermission != value) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                }

                _flags[ Flag_RequirePermission ] = value;
                _modifiedFlags[ Flag_RequirePermission ] = true;
            }
        }

        internal bool RequirePermissionModified {
            get {
                return _modifiedFlags[ Flag_RequirePermission ];
            }
        }

        public string Type {
            get {return _typeName;}
            set {
                if (String.IsNullOrEmpty(value)) {
                    throw ExceptionUtil.PropertyNullOrEmpty("Type");
                }

                VerifyIsEditable();
                VerifyIsEditableFactory();

                // allow type to be different from current type,
                // so long as it doesn't conflict with a type already defined
                FactoryRecord factoryRecord = FindParentFactoryRecord(false);
                if (factoryRecord != null) {
                    IInternalConfigHost host = null;
                    if (_configRecord != null) {
                        host = _configRecord.Host;
                    }

                    if (!factoryRecord.IsEquivalentType(host, value)) {
                        throw new ConfigurationErrorsException(SR.GetString(SR.Config_tag_name_already_defined, _configKey));
                    }
                }

                _typeName = value;
            }
        }

        public ConfigurationSection GetParentSection() {
            VerifyDesigntime();

            if ( _flags[ Flag_IsParentSection ] ) {
                throw new InvalidOperationException(SR.GetString(SR.Config_getparentconfigurationsection_first_instance));
            }

            // if a users create a configsection with : sectionType sec  = new sectionType();
            // the config record will be null.  Return null for the parent in this case.
            ConfigurationSection ancestor = null;
            if (_configRecord != null) {
                ancestor = _configRecord.FindAndCloneImmediateParentSection(_configurationSection);
                if (ancestor != null) {
                    ancestor.SectionInformation._flags[Flag_IsParentSection]     = true;
                    ancestor.SetReadOnly();
                }
            }

            return ancestor;
        }

        public string GetRawXml() {
            VerifyDesigntime();
            VerifyNotParentSection();

            if (RawXml != null) {
                return RawXml;
            }
            else if (_configRecord != null) {
                return _configRecord.GetRawXml(_configKey);
            }
            else {
                return null;
            }
        }

        public void SetRawXml(string rawXml) {
            VerifyIsEditable();

            if (_configRecord != null) {
                _configRecord.SetRawXml(_configurationSection, rawXml);
            }
            else {
                RawXml = (String.IsNullOrEmpty(rawXml)) ? null : rawXml;
            }
        }

        internal string RawXml {
            get {
                return _rawXml;
            }

            set {
                _rawXml = value;
            }
        }

        // True if the section will be serialized to the current hierarchy level, regardless of
        // ConfigurationSaveMode.
        public bool ForceSave
        {
            get {
                return _flags[ Flag_ForceSave ];
            }
            set {
                VerifyIsEditable();

                _flags[ Flag_ForceSave ] = value;
            }
        }

        public void RevertToParent() {
            VerifyIsEditable();
            VerifyIsAttachedToConfigRecord();

            _configRecord.RevertToParent(_configurationSection);
        }
    }
}


text:
package com.github.dpmorocho.obd.comandos.presion;

import com.github.dpmorocho.obd.comandos.ObdCommand;
import com.github.dpmorocho.obd.comandos.SystemOfUnits;

/**
 * Abstract pressure command.
 */
public abstract class PressureCommand extends ObdCommand implements
        SystemOfUnits {

    protected int tempValue = 0;
    protected int pressure = 0;

    /**
     * Default ctor
     *
     * @param cmd a {@link java.lang.String} object.
     */
    public PressureCommand(String cmd) {
        super(cmd);
    }

    /**
     * Copy ctor.
     *
     * @param other a {@link PressureCommand} object.
     */
    public PressureCommand(PressureCommand other) {
        super(other);
    }

    /**
     * Some PressureCommand subclasses will need to implement this method in
     * order to determine the final kPa value.
     *
     * *NEED* to read tempValue
     *
     * @return a int.
     */
    protected int preparePressureValue() {
        return buffer.get(2);
    }

    protected void performCalculations() {
        // ignore first two bytes [hh hh] of the response
        pressure = preparePressureValue();
    }

    @Override
    public String getFormattedResult() {
        return useImperialUnits ? String.format("%.1f%s", getImperialUnit(), getResultUnit())
                : String.format("%d%s", pressure, getResultUnit());
    }

    /**
     * @return the pressure in kPa
     */
    public int getMetricUnit() {
        return pressure;
    }

    /**
     * @return the pressure in psi
     */
    public float getImperialUnit() {
        return Double.valueOf(pressure * 0.145037738).floatValue();
    }

    @Override
    public String getCalculatedResult() {
        return useImperialUnits ? String.valueOf(getImperialUnit()) : String.valueOf(pressure);
    }

    @Override
    public String getResultUnit() {
        return useImperialUnits ? "psi" : "kPa";
    }

}


text:
<?php
namespace Lib\Net;

/**
 * Transfering files.
 */
class Transfer {
	/**
	 * Downloads file from internet.
	 * @param string $url URL of the file.
	 * @param string $output Output file.
	 * @param bool $verbose True for verbose output, false otherwise.
	 */
	public static function download(string $url, string $output, bool $verbose = false): void {
		$curl = curl_init($url);
		if($curl !== false) {
			$folder = dirname($output);
			if(!is_dir($folder)) {
				mkdir($folder, 0755, true);
			}

			$file = fopen($output, "w");
			if($file !== false) {
				if($verbose == true) {
					curl_setopt($curl, CURLOPT_VERBOSE, true);
				}
				curl_setopt($curl, CURLINFO_HEADER_OUT, true);
				curl_setopt($curl, CURLOPT_FAILONERROR, true);
				curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
				curl_setopt($curl, CURLOPT_FRESH_CONNECT, true);
				curl_setopt($curl, CURLOPT_FILE, $file);

				curl_exec($curl);
				if($verbose == true) {
					echo curl_getinfo($curl, CURLINFO_HEADER_OUT);
					echo "Saved to ".$output.".\n";
				}
				curl_close($curl);
				fclose($file);
			}
		}
	}
}


text:
package org.usfirst.frc.team166.robot.commands.autonomous;

import edu.wpi.first.wpilibj.command.Command;

import org.usfirst.frc.team166.robot.Robot;

/**
 *
 */
public class DriveToDrop extends Command {

	public DriveToDrop() {
		requires(Robot.drive);
	}

	// Called just before this Command runs the first time
	@Override
	protected void initialize() {

	}

	// Called repeatedly when this Command is scheduled to run
	@Override
	protected void execute() {// 1.3 is 2.5 and 9 is 17in
		Robot.drive.centerOnTote();
	}

	// Make this return true when this Command no longer needs to run execute()
	@Override
	protected boolean isFinished() {
		return (Robot.drive.distanceToTote() < 1.5); // slightly larger than 1.3 to compensate for coasting
	}

	// Called once after isFinished returns true
	@Override
	protected void end() {
		Robot.drive.stopMotors();
	}

	// Called when another command which requires one or more of the same
	// subsystems is scheduled to run
	@Override
	protected void interrupted() {
	}
}


text:
package cop.raml.it.foo.dto;

public class ExportDataDTO {

    private String header;
    private String data;
}