text:
set -e

CURDIR=$(cd $(dirname "$0"); pwd)
# Get BUILDDIR and REAL_MONETAD
. "${CURDIR}/tests-config.sh"

export MONETACLI=${BUILDDIR}/qa/pull-tester/run-moneta-cli
export MONETAD=${REAL_MONETAD}

if [ "x${EXEEXT}" = "x.exe" ]; then
  echo "Win tests currently disabled"
  exit 0
fi

#Run the tests

if [ "x${ENABLE_MONETAD}${ENABLE_UTILS}${ENABLE_WALLET}" = "x111" ]; then
  ${BUILDDIR}/qa/rpc-tests/wallet.py --srcdir "${BUILDDIR}/src"
  ${BUILDDIR}/qa/rpc-tests/listtransactions.py --srcdir "${BUILDDIR}/src"
  ${BUILDDIR}/qa/rpc-tests/mempool_resurrect_test.py --srcdir "${BUILDDIR}/src"
  ${BUILDDIR}/qa/rpc-tests/txn_doublespend.py --srcdir "${BUILDDIR}/src"
  ${BUILDDIR}/qa/rpc-tests/txn_doublespend.py --mineblock --srcdir "${BUILDDIR}/src"
  ${BUILDDIR}/qa/rpc-tests/getchaintips.py --srcdir "${BUILDDIR}/src"
  ${BUILDDIR}/qa/rpc-tests/rest.py --srcdir "${BUILDDIR}/src"
  ${BUILDDIR}/qa/rpc-tests/mempool_spendcoinbase.py --srcdir "${BUILDDIR}/src"
  ${BUILDDIR}/qa/rpc-tests/httpbasics.py --srcdir "${BUILDDIR}/src"
  ${BUILDDIR}/qa/rpc-tests/mempool_coinbase_spends.py --srcdir "${BUILDDIR}/src"
  #${BUILDDIR}/qa/rpc-tests/forknotify.py --srcdir "${BUILDDIR}/src"
else
  echo "No rpc tests to run. Wallet, utils, and monetad must all be enabled"
fi


text:
/*Generated! Do not modify!*/ package generated.fliesenui.screen;
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/ import java.util.Map;
/*Generated! Do not modify!*/ import com.google.gson.Gson;
/*Generated! Do not modify!*/ import java.io.InputStream;
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/ import generated.fliesenui.core.FLUIScreen;
/*Generated! Do not modify!*/ import generated.fliesenui.core.FLUIRequest;
/*Generated! Do not modify!*/ import generated.fliesenui.core.FLUIAbstractReply;
/*Generated! Do not modify!*/ import generated.fliesenui.core.FLUIScreenManagerInterface;
/*Generated! Do not modify!*/ import generated.fliesenui.core.FLUIString.StringLanguage;
/*Generated! Do not modify!*/ import generated.fliesenui.core.FLUIUtil;
/*Generated! Do not modify!*/ import generated.fliesenui.core.CallbackMethodCall;
/*Generated! Do not modify!*/ import generated.fliesenui.core.FLUIOpenScreenException;
/*Generated! Do not modify!*/ import generated.fliesenui.core.FLUIClientPropertiesDTO;
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/ import generated.fliesenui.dto.DetailsParameterDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.DetailsParameterListDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.EditStateDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.EditStateListDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.IdAndLabelDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.IdAndLabelListDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.IdAndLabelListListDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.OverviewItemDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.OverviewItemListDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.OverviewListDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.OverviewListListDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.OverviewParameterDTO;
/*Generated! Do not modify!*/ import generated.fliesenui.dto.OverviewParameterListDTO;
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/ public class OverviewView implements FLUIScreen {
/*Generated! Do not modify!*/     private OverviewListener listener;
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/     public OverviewView(OverviewListener listener) {
/*Generated! Do not modify!*/         this.listener = listener;
/*Generated! Do not modify!*/     }
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/     public FLUIAbstractReply onFLUIRequest(FLUIScreenManagerInterface manager, boolean recordMode, FLUIRequest request, String uploadedFileName, InputStream uploadedFileInputStream) throws Exception{
/*Generated! Do not modify!*/         Map<String, Object> parameters = request.getParameters();
/*Generated! Do not modify!*/         String action = request.getAction();
/*Generated! Do not modify!*/         StringLanguage currentLanguage = null;
/*Generated! Do not modify!*/         try{
/*Generated! Do not modify!*/             currentLanguage = StringLanguage.valueOf(request.getCurrentLanguage());
/*Generated! Do not modify!*/         } catch (Exception ignored){
/*Generated! Do not modify!*/         }
/*Generated! Do not modify!*/         Gson gson = new Gson();
/*Generated! Do not modify!*/         OverviewReply reply = new OverviewReply(recordMode, currentLanguage);
/*Generated! Do not modify!*/         if ("widgetButtonMenuButtonClicked".equals(action)) {
/*Generated! Do not modify!*/             listener.onMenuButtonClicked(reply, gson.fromJson((String)parameters.get("parameter"), OverviewParameterDTO.class));
/*Generated! Do not modify!*/         } else if ("onNotesTableRowClicked".equals(action)) {
/*Generated! Do not modify!*/             listener.onNotesTableRowClicked(reply, (String)parameters.get("rowID"), gson.fromJson((String)parameters.get("parameter"), OverviewParameterDTO.class));
/*Generated! Do not modify!*/         } else if ("onLoaded".equals(action)) {
/*Generated! Do not modify!*/             listener.onLoaded(reply, gson.fromJson((String)parameters.get("_ClientProperties"), FLUIClientPropertiesDTO.class), gson.fromJson((String)parameters.get("parameter"), OverviewParameterDTO.class));
/*Generated! Do not modify!*/         } else if ("onInputDialogResult".equals(action)) {
/*Generated! Do not modify!*/             onStringInputDialogResult(reply, action, parameters);
/*Generated! Do not modify!*/         } else if ("onConfirmDialogResult".equals(action)) {
/*Generated! Do not modify!*/             onConfirmDialogResult(reply, action, parameters);
/*Generated! Do not modify!*/         } else if ("onListChooserResult".equals(action)) {
/*Generated! Do not modify!*/             onListChooserDialogResult(reply, action, parameters);
/*Generated! Do not modify!*/         }
/*Generated! Do not modify!*/         return reply;
/*Generated! Do not modify!*/     }
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/     private void onConfirmDialogResult(OverviewReply reply, String action, Map<String, Object> parameters){
/*Generated! Do not modify!*/         String callbackDataString = (String)parameters.get("callbackData");
/*Generated! Do not modify!*/         String referenceID = (String)parameters.get("referenceID");
/*Generated! Do not modify!*/         boolean result = (boolean)parameters.get("result");
/*Generated! Do not modify!*/         if (callbackDataString == null){
/*Generated! Do not modify!*/             listener.onConfirmDialogResult(reply, referenceID, result);
/*Generated! Do not modify!*/             return;
/*Generated! Do not modify!*/         }
/*Generated! Do not modify!*/     }
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/     private void onStringInputDialogResult(OverviewReply reply, String action, Map<String, Object> parameters){
/*Generated! Do not modify!*/         String callbackDataString = (String)parameters.get("callbackData");
/*Generated! Do not modify!*/         String referenceID = (String)parameters.get("referenceID");
/*Generated! Do not modify!*/         String result = (String)parameters.get("result");
/*Generated! Do not modify!*/         if (callbackDataString == null){
/*Generated! Do not modify!*/             listener.onInputDialogResult(reply, referenceID, result);
/*Generated! Do not modify!*/             return;
/*Generated! Do not modify!*/         }
/*Generated! Do not modify!*/     }
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/     private void onListChooserDialogResult(OverviewReply reply, String action, Map<String, Object> parameters){
/*Generated! Do not modify!*/         String callbackDataString = (String)parameters.get("callbackData");
/*Generated! Do not modify!*/         String referenceID = (String)parameters.get("referenceID");
/*Generated! Do not modify!*/         java.util.List<String> result = (java.util.List<String>)parameters.get("selectedIDs");
/*Generated! Do not modify!*/         if (callbackDataString == null){
/*Generated! Do not modify!*/             listener.onListChooserResult(reply, referenceID, result);
/*Generated! Do not modify!*/             return;
/*Generated! Do not modify!*/         }
/*Generated! Do not modify!*/     }
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/
/*Generated! Do not modify!*/     @Override
/*Generated! Do not modify!*/     public String getID() {
/*Generated! Do not modify!*/         return "overview";
/*Generated! Do not modify!*/     }
/*Generated! Do not modify!*/     private void setOpenScreen(OverviewReply reply, FLUIOpenScreenException exception){
/*Generated! Do not modify!*/         switch (exception.getScreenID()) {
/*Generated! Do not modify!*/         case "about":
/*Generated! Do not modify!*/             reply.openScreenAbout((OverviewParameterDTO)exception.getParameterDTO());
/*Generated! Do not modify!*/             break;
/*Generated! Do not modify!*/         case "details":
/*Generated! Do not modify!*/             reply.openScreenDetails((DetailsParameterDTO)exception.getParameterDTO());
/*Generated! Do not modify!*/             break;
/*Generated! Do not modify!*/         case "login":
/*Generated! Do not modify!*/             reply.openScreenLogin();
/*Generated! Do not modify!*/             break;
/*Generated! Do not modify!*/         case "markdownHelp":
/*Generated! Do not modify!*/             reply.openScreenMarkdownHelp((OverviewParameterDTO)exception.getParameterDTO());
/*Generated! Do not modify!*/             break;
/*Generated! Do not modify!*/         case "overview":
/*Generated! Do not modify!*/             reply.openScreenOverview((OverviewParameterDTO)exception.getParameterDTO());
/*Generated! Do not modify!*/             break;
/*Generated! Do not modify!*/         }
/*Generated! Do not modify!*/     }
/*Generated! Do not modify!*/ }

redpajama_set_name: RedPajamaGithub


text:
// Copyright (c) Microsoft Open Technologies, Inc.  All rights reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
// This source file is machine generated.  Please do not change the code manually.
using System;
using System.Collections.Generic;
using System.IO.Packaging;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Spreadsheet;

namespace DocumentFormat.OpenXml.Office2010.ExcelAc
{
/// <summary>
/// <para>Defines the List Class.</para>
///<para>This class is only available in Office2013.</para>
/// <para> When the object is serialized out as xml, its qualified name is x12ac:list.</para>
/// </summary>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
[System.CodeDom.Compiler.GeneratedCode("DomGen", "2.0")]
[OfficeAvailability(FileFormatVersions.Office2013)]
public partial class List : OpenXmlLeafTextElement
{
    private const string tagName = "list";
    /// <summary>
    /// Gets the local name of the element.
    /// </summary>
    public override string LocalName
    {
        get { return tagName; }
    }

    private const byte tagNsId = 72;
    internal override byte NamespaceId
    {
        get { return tagNsId; }
    }

    internal const int ElementTypeIdConst = 13429;

    /// <summary>
    /// Gets the type ID of the element.
    /// </summary>
    internal override int ElementTypeId
    {
		get { return ElementTypeIdConst; }
    }

    /// <summary>
    /// Whether this element is available in a specific version of Office Application.
    /// </summary>
    /// <param name="version">The Office file format version.</param>
    /// <returns>Returns true if the element is defined in the specified version.</returns>
    internal override bool IsInVersion(FileFormatVersions version)
    {
		if((4 & (int)version) > 0)
		{
			return true;
		}
		return false;
    }

    /// <summary>
    /// Initializes a new instance of the List class.
    /// </summary>
    public List():base(){}

           /// <summary>
    /// Initializes a new instance of the List class with the specified text content.
    /// </summary>
    /// <param name="text">Specifies the text content of the element.</param>
    public List(string text):base(text)
    {
    }

    internal override OpenXmlSimpleType InnerTextToValue(string text)
    {

		return new StringValue(){ InnerText = text };
    }

        /// <summary>
    /// Creates a duplicate of this node.
    /// </summary>
    /// <param name="deep">True to recursively clone the subtree under the specified node; false to clone only the node itself. </param>
    /// <returns>Returns the cloned node. </returns>
    public override OpenXmlElement CloneNode(bool deep)
    {
        return CloneImp<List>(deep);
    }

}
}


text:
package com.cisco.axl.api._8;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;

/**
 *
Java class for GetRouteFilterRes complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType name="GetRouteFilterRes">
 *   <complexContent>
 *     <extension base="{http://www.cisco.com/AXL/API/8.0}APIResponse">
 *       <sequence>
 *         <element name="return">
 *           <complexType>
 *             <complexContent>
 *               <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *                 <sequence>
 *                   <element name="routeFilter" type="{http://www.cisco.com/AXL/API/8.0}RRouteFilter"/>
 *                 </sequence>
 *               </restriction>
 *             </complexContent>
 *           </complexType>
 *         </element>
 *       </sequence>
 *     </extension>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "GetRouteFilterRes", propOrder = {
    "_return"
})
public class GetRouteFilterRes
    extends APIResponse
{

    @XmlElement(name = "return", required = true)
    protected GetRouteFilterRes.Return _return;

    /**
     * Gets the value of the return property.
     *
     * @return
     *     possible object is
     *     {@link GetRouteFilterRes.Return }
     *
     */
    public GetRouteFilterRes.Return getReturn() {
        return _return;
    }

    /**
     * Sets the value of the return property.
     *
     * @param value
     *     allowed object is
     *     {@link GetRouteFilterRes.Return }
     *
     */
    public void setReturn(GetRouteFilterRes.Return value) {
        this._return = value;
    }

    /**
     *
Java class for anonymous complex type.
     *
     *
The following schema fragment specifies the expected content contained within this class.
     *
     *

     * <complexType>
     *   <complexContent>
     *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
     *       <sequence>
     *         <element name="routeFilter" type="{http://www.cisco.com/AXL/API/8.0}RRouteFilter"/>
     *       </sequence>
     *     </restriction>
     *   </complexContent>
     * </complexType>
     *

     *
     *
     */
    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlType(name = "", propOrder = {
        "routeFilter"
    })
    public static class Return {

        @XmlElement(required = true)
        protected RRouteFilter routeFilter;

        /**
         * Gets the value of the routeFilter property.
         *
         * @return
         *     possible object is
         *     {@link RRouteFilter }
         *
         */
        public RRouteFilter getRouteFilter() {
            return routeFilter;
        }

        /**
         * Sets the value of the routeFilter property.
         *
         * @param value
         *     allowed object is
         *     {@link RRouteFilter }
         *
         */
        public void setRouteFilter(RRouteFilter value) {
            this.routeFilter = value;
        }

    }

}


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

    <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
    <title>Statistics of Poss in UD_German-GSD</title>
    <link rel="root" href=""/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css">
    <link rel="stylesheet" type="text/css" href="../../css/jquery-ui-redmond.css"/>
    <link rel="stylesheet" type="text/css" href="../../css/style.css"/>
    <link rel="stylesheet" type="text/css" href="../../css/style-vis.css"/>
    <link rel="stylesheet" type="text/css" href="../../css/hint.css"/>

          home

          edit page
          issue tracker

          <gcse:search></gcse:search>

        This page pertains to UD version 2.

            It appears that you have Javascript disabled.
            Please consider enabling Javascript for this page to see the visualizations.

Treebank Statistics: UD_German-GSD: Features: Poss

This feature is universal.
It occurs with 1 different values: Yes.

2406 tokens (1%) have a non-empty value of Poss.
52 types (0%) occur at least once with a non-empty value of Poss.
11 lemmas (0%) occur at least once with a non-empty value of Poss.
The feature is used with 3 part-of-speech tags: <tt>DET</tt> (2380; 1% instances), <tt>PRON</tt> (24; 0% instances), <tt>PROPN</tt> (2; 0% instances).

DET

2380 <tt>DET</tt> tokens (6% of all DET tokens) have a non-empty value of Poss.

The most frequent other feature values with which DET and Poss co-occurred: <tt>Definite</tt><tt>=EMPTY</tt> (2380; 100%), <tt>PronType</tt><tt>=Prs</tt> (2298; 97%), <tt>Number</tt><tt>=Sing</tt> (1869; 79%).

DET tokens may have the following values of Poss:

Yes (2380; 100% of non-empty Poss): seine, seiner, sein, ihre, seinen, seinem, ihren, ihrer, ihr, ihrem

EMPTY (35281): der, die, dem, den, das, des, eine, ein, einer, einem

PRON

24 <tt>PRON</tt> tokens (0% of all PRON tokens) have a non-empty value of Poss.

The most frequent other feature values with which PRON and Poss co-occurred: <tt>Person</tt><tt>=EMPTY</tt> (24; 100%), <tt>Reflex</tt><tt>=EMPTY</tt> (24; 100%), <tt>PronType</tt><tt>=EMPTY</tt> (23; 96%), <tt>Number</tt><tt>=Sing</tt> (21; 88%), <tt>Gender</tt><tt>=Neut</tt> (14; 58%).

PRON tokens may have the following values of Poss:

Yes (24; 100% of non-empty Poss): ihr, euren, eurer, deren, meiner

EMPTY (14179): er, sich, sie, es, die, ich, der, man, diese, das

PROPN

2 <tt>PROPN</tt> tokens (0% of all PROPN tokens) have a non-empty value of Poss.

The most frequent other feature values with which PROPN and Poss co-occurred: <tt>Number</tt><tt>=Plur</tt> (2; 100%).

PROPN tokens may have the following values of Poss:

Yes (2; 100% of non-empty Poss): SC, SYNODUS

EMPTY (30678): Deutschland, de, of, US, Berlin, the, SPD, St., new, Oktober

© 2014–2021
            Universal Dependencies contributors.
            Site powered by Annodoc and brat
.


text:
package org.jkiss.dbeaver.model.impl.jdbc.exec;

import org.jkiss.code.NotNull;
import org.jkiss.code.Nullable;
import org.jkiss.dbeaver.DBException;
import org.jkiss.dbeaver.Log;
import org.jkiss.dbeaver.model.DBPDataKind;
import org.jkiss.dbeaver.model.DBPDataSource;
import org.jkiss.dbeaver.model.DBUtils;
import org.jkiss.dbeaver.model.exec.DBCException;
import org.jkiss.dbeaver.model.exec.DBCSession;
import org.jkiss.dbeaver.model.exec.jdbc.JDBCCallableStatement;
import org.jkiss.dbeaver.model.exec.jdbc.JDBCResultSet;
import org.jkiss.dbeaver.model.exec.jdbc.JDBCSession;
import org.jkiss.dbeaver.model.impl.DBObjectNameCaseTransformer;
import org.jkiss.dbeaver.model.impl.jdbc.JDBCDataSource;
import org.jkiss.dbeaver.model.impl.jdbc.JDBCUtils;
import org.jkiss.dbeaver.model.sql.SQLDataSource;
import org.jkiss.dbeaver.model.struct.DBSDataType;
import org.jkiss.dbeaver.model.struct.DBSObject;
import org.jkiss.dbeaver.model.struct.DBSObjectContainer;
import org.jkiss.dbeaver.model.struct.rdb.DBSProcedure;
import org.jkiss.dbeaver.model.struct.rdb.DBSProcedureContainer;
import org.jkiss.dbeaver.model.struct.rdb.DBSProcedureParameter;
import org.jkiss.dbeaver.model.struct.rdb.DBSProcedureParameterKind;
import org.jkiss.utils.CommonUtils;

import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.*;
import java.util.Calendar;
import java.util.Collection;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Managable base statement.
 * Stores information about execution in query manager and operated progress monitor.
 */
public class JDBCCallableStatementImpl extends JDBCPreparedStatementImpl implements JDBCCallableStatement {

    private static final Log log = Log.getLog(JDBCCallableStatementImpl.class);
    private static final Pattern EXEC_PATTERN = Pattern.compile("[\\w_\\.]+\\s+([^(]+)\\s*\\(");

    private DBSProcedure procedure;
    private JDBCResultSetCallable procResults;

    public JDBCCallableStatementImpl(
        @NotNull JDBCSession connection,
        @NotNull CallableStatement original,
        @Nullable String query,
        boolean disableLogging)
    {
        super(connection, original, query, disableLogging);

        procResults = new JDBCResultSetCallable(getConnection(), this);

        // Find procedure definition
        try {
            procedure = findProcedure(connection, query);
        } catch (Throwable e) {
            log.debug(e);
        }

        // Bind procedure parameters
        try {
            ParameterMetaData paramsMeta = original.getParameterMetaData();
            if (paramsMeta != null) {
                int paramsCount = bindProcedureFromJDBC(paramsMeta);
                if (procedure != null && paramsCount == 0 && hasOutputParameters()) {
                    try {
                        bindProcedureFromMeta();
                    } catch (Throwable e) {
                        log.debug("Error binding procedure output parameters", e);
                    }
                }
            }
        } catch (Throwable e) {
            log.debug(e.getMessage());
            // Try to bind parameters from procedure meta info
            try {
                if (procedure != null) {
                    bindProcedureFromMeta();
                }
            } catch (Throwable e1) {
                log.debug("Error binding procedure output parameters", e1);
            }
        }

        if (procedure != null) {
            try {
                Collection<? extends DBSProcedureParameter> params = procedure.getParameters(getConnection().getProgressMonitor());
                if (!CommonUtils.isEmpty(params)) {
                    for (DBSProcedureParameter param : params) {
                        if (param.getParameterKind() == DBSProcedureParameterKind.OUT ||
                            param.getParameterKind() == DBSProcedureParameterKind.INOUT ||
                            param.getParameterKind() == DBSProcedureParameterKind.RETURN)
                        {
                            procResults.addColumn(param.getName(), param.getParameterType());
                        }
                    }
                }
            } catch (DBException e) {
                log.debug("Error extracting callable results", e);
            }
        } else {
            // Try to make columns from parameters meta
            try {
                JDBCDataSource dataSource = connection.getDataSource();
                ParameterMetaData paramsMeta = original.getParameterMetaData();
                int parameterCount = paramsMeta.getParameterCount();
                if (parameterCount > 0) {
                    for (int index = 0; index < parameterCount; index++) {
                        int parameterMode = paramsMeta.getParameterMode(index + 1);
                        if (parameterMode == ParameterMetaData.parameterModeOut || parameterMode == ParameterMetaData.parameterModeInOut) {
                            DBSDataType dataType = dataSource.getLocalDataType(paramsMeta.getParameterTypeName(index + 1));
                            if (dataType == null) {
                                DBPDataKind dataKind = JDBCUtils.resolveDataKind(dataSource, paramsMeta.getParameterTypeName(index + 1), paramsMeta.getParameterType(index + 1));
                                procResults.addColumn(String.valueOf(index + 1), dataKind);
                            } else {
                                procResults.addColumn(String.valueOf(index + 1), dataType);
                            }
                        }
                    }
                }
            } catch (Throwable e) {
                log.debug("Error extracting parameters meta data: " + e.getMessage());
            }
        }
        procResults.addRow();
    }

    private static DBSProcedure findProcedure(DBCSession session, String queryString) throws DBException {
        DBPDataSource dataSource = session.getDataSource();
        if (!CommonUtils.isEmpty(queryString)) {
            Matcher matcher = EXEC_PATTERN.matcher(queryString);
            if (matcher.find()) {
                String procName = matcher.group(1);
                char divChar = 0;
                if (dataSource instanceof SQLDataSource) {
                    divChar = ((SQLDataSource) dataSource).getSQLDialect().getStructSeparator();
                }
                if (procName.indexOf(divChar) != -1) {
                    return findProcedureByNames(session, procName.split("\\" + divChar));
                } else {
                    return findProcedureByNames(session, procName);
                }
            }
        }

        return null;
    }

    private static DBSProcedure findProcedureByNames(@NotNull DBCSession session, @NotNull String... names) throws DBException {
        if (!(session.getDataSource() instanceof DBSObjectContainer)) {
            return null;
        }
        DBSObjectContainer container = (DBSObjectContainer) session.getDataSource();
        if (names.length == 1) {
            DBSObject[] selectedObjects = DBUtils.getSelectedObjects(session.getProgressMonitor(), container);
            if (selectedObjects.length > 0 && selectedObjects[selectedObjects.length - 1] instanceof DBSObjectContainer) {
                container = (DBSObjectContainer) selectedObjects[selectedObjects.length - 1];
            }
        } else {
            container = (DBSObjectContainer) session.getDataSource();
            for (int i = 0; i < names.length - 1; i++) {
                DBSObject child = container.getChild(session.getProgressMonitor(), DBObjectNameCaseTransformer.transformName(session.getDataSource(), names[i]));
                if (child instanceof DBSObjectContainer) {
                    container = (DBSObjectContainer) child;
                } else {
                    return null;
                }
            }
        }
        if (container instanceof DBSProcedureContainer) {
            return ((DBSProcedureContainer) container).getProcedure(session.getProgressMonitor(), DBObjectNameCaseTransformer.transformName(session.getDataSource(), names[names.length - 1]));
        }
        return null;
    }

    @Override
    public CallableStatement getOriginal()
    {
        return (CallableStatement)original;
    }

    ////////////////////////////////////////////////////////////////////
    // Procedure bindings
    ////////////////////////////////////////////////////////////////////

    private int bindProcedureFromJDBC(@NotNull ParameterMetaData paramsMeta) throws DBException {
        try {
            int parameterCount = paramsMeta.getParameterCount();
            if (parameterCount > 0) {
                int outParameters = 0;
                for (int index = 0; index < parameterCount; index++) {
                    int parameterMode = paramsMeta.getParameterMode(index + 1);
                    if (parameterMode == ParameterMetaData.parameterModeOut || parameterMode == ParameterMetaData.parameterModeInOut) {
                        registerOutParameter(index + 1, paramsMeta.getParameterType(index + 1));
                        outParameters++;
                    }
                }
                return outParameters;
            }
            return parameterCount;
        } catch (SQLException e) {
            throw new DBException("Error binding callable statement parameters from metadata: " + e.getMessage(), e);
        }
    }

    private boolean hasOutputParameters() throws DBException {
        if (procedure == null) {
            return false;
        }
        Collection<? extends DBSProcedureParameter> params = procedure.getParameters(getConnection().getProgressMonitor());
        if (!CommonUtils.isEmpty(params)) {
            for (DBSProcedureParameter param : params) {
                if (param.getParameterKind() == DBSProcedureParameterKind.OUT || param.getParameterKind() == DBSProcedureParameterKind.INOUT) {
                    return true;
                }
            }
        }
        return false;
    }

    private void bindProcedureFromMeta() throws DBException {
        if (procedure == null) {
            return;
        }
        try {
            Collection<? extends DBSProcedureParameter> params = procedure.getParameters(getConnection().getProgressMonitor());
            if (!CommonUtils.isEmpty(params)) {
                int index = 0;
                for (DBSProcedureParameter param : params) {
                    if (param.getParameterKind() == DBSProcedureParameterKind.OUT || param.getParameterKind() == DBSProcedureParameterKind.INOUT) {
                        index++;
                        registerOutParameter(index, param.getParameterType().getTypeID());
                    }
                }
            }
        } catch (SQLException e) {
            throw new DBException("Error binding callable statement parameters", e);
        }
    }

    @Override
    public boolean executeStatement() throws DBCException {
        boolean hasResults = super.executeStatement();
        if (!hasResults && procResults.getColumnCount() > 0) {
            return true;
        }
        return hasResults;
    }

    @Nullable
    @Override
    public JDBCResultSet getResultSet()
        throws SQLException
    {
        JDBCResultSet resultSet = makeResultSet(getOriginal().getResultSet());
        if (resultSet == null && procResults != null) {
            return procResults;
        }
        return resultSet;
    }

    ////////////////////////////////////////////////////////////////////
    // JDBC Callable Statement overrides
    ////////////////////////////////////////////////////////////////////

    @Override
    public void registerOutParameter(int parameterIndex, int sqlType)
        throws SQLException
    {
        getOriginal().registerOutParameter(parameterIndex, sqlType);
    }

    @Override
    public void registerOutParameter(int parameterIndex, int sqlType, int scale)
        throws SQLException
    {
        getOriginal().registerOutParameter(parameterIndex, sqlType, scale);
    }

    @Override
    public boolean wasNull()
        throws SQLException
    {
        return getOriginal().wasNull();
    }

    @Override
    public String getString(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getString(parameterIndex);
    }

    @Override
    public boolean getBoolean(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getBoolean(parameterIndex);
    }

    @Override
    public byte getByte(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getByte(parameterIndex);
    }

    @Override
    public short getShort(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getShort(parameterIndex);
    }

    @Override
    public int getInt(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getInt(parameterIndex);
    }

    @Override
    public long getLong(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getLong(parameterIndex);
    }

    @Override
    public float getFloat(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getFloat(parameterIndex);
    }

    @Override
    public double getDouble(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getDouble(parameterIndex);
    }

    @Override
    @Deprecated
    public BigDecimal getBigDecimal(int parameterIndex, int scale)
        throws SQLException
    {
        return getOriginal().getBigDecimal(parameterIndex, scale);
    }

    @Override
    public byte[] getBytes(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getBytes(parameterIndex);
    }

    @Override
    public Date getDate(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getDate(parameterIndex);
    }

    @Override
    public Time getTime(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getTime(parameterIndex);
    }

    @Override
    public Timestamp getTimestamp(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getTimestamp(parameterIndex);
    }

    @Override
    public Object getObject(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getObject(parameterIndex);
    }

    @Override
    public BigDecimal getBigDecimal(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getBigDecimal(parameterIndex);
    }

    @Override
    public Object getObject(int parameterIndex, Map<String, Class<?>> map)
        throws SQLException
    {
        return getOriginal().getObject(parameterIndex, map);
    }

    @Override
    public Ref getRef(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getRef(parameterIndex);
    }

    @Override
    public Blob getBlob(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getBlob(parameterIndex);
    }

    @Override
    public Clob getClob(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getClob(parameterIndex);
    }

    @Override
    public Array getArray(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getArray(parameterIndex);
    }

    @Override
    public Date getDate(int parameterIndex, Calendar cal)
        throws SQLException
    {
        return getOriginal().getDate(parameterIndex, cal);
    }

    @Override
    public Time getTime(int parameterIndex, Calendar cal)
        throws SQLException
    {
        return getOriginal().getTime(parameterIndex, cal);
    }

    @Override
    public Timestamp getTimestamp(int parameterIndex, Calendar cal)
        throws SQLException
    {
        return getOriginal().getTimestamp(parameterIndex, cal);
    }

    ////////////////////////////////////////////////////////
    // Output parameters mapping

    @Override
    public void registerOutParameter(int parameterIndex, int sqlType, String typeName)
        throws SQLException
    {
        getOriginal().registerOutParameter(parameterIndex, sqlType, typeName);
    }

    @Override
    public void registerOutParameter(String parameterName, int sqlType)
        throws SQLException
    {
        getOriginal().registerOutParameter(parameterName, sqlType);
    }

    @Override
    public void registerOutParameter(String parameterName, int sqlType, int scale)
        throws SQLException
    {
        getOriginal().registerOutParameter(parameterName, sqlType, scale);
    }

    @Override
    public void registerOutParameter(String parameterName, int sqlType, String typeName)
        throws SQLException
    {
        getOriginal().registerOutParameter(parameterName, sqlType, typeName);
    }

    ////////////////////////////////////////////////////////
    // Output parameters mapping

    public URL getURL(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getURL(parameterIndex);
    }

    @Override
    public void setURL(String parameterName, URL val)
        throws SQLException
    {
        getOriginal().setURL(parameterName, val);
        handleStatementBind(parameterName, val);
    }

    @Override
    public void setNull(String parameterName, int sqlType)
        throws SQLException
    {
        getOriginal().setNull(parameterName, sqlType);
        handleStatementBind(parameterName, null);
    }

    @Override
    public void setBoolean(String parameterName, boolean x)
        throws SQLException
    {
        getOriginal().setBoolean(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setByte(String parameterName, byte x)
        throws SQLException
    {
        getOriginal().setByte(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setShort(String parameterName, short x)
        throws SQLException
    {
        getOriginal().setShort(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setInt(String parameterName, int x)
        throws SQLException
    {
        getOriginal().setInt(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setLong(String parameterName, long x)
        throws SQLException
    {
        getOriginal().setLong(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setFloat(String parameterName, float x)
        throws SQLException
    {
        getOriginal().setFloat(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setDouble(String parameterName, double x)
        throws SQLException
    {
        getOriginal().setDouble(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setBigDecimal(String parameterName, BigDecimal x)
        throws SQLException
    {
        getOriginal().setBigDecimal(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setString(String parameterName, String x)
        throws SQLException
    {
        getOriginal().setString(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setBytes(String parameterName, byte[] x)
        throws SQLException
    {
        getOriginal().setBytes(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setDate(String parameterName, Date x)
        throws SQLException
    {
        getOriginal().setDate(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setTime(String parameterName, Time x)
        throws SQLException
    {
        getOriginal().setTime(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setTimestamp(String parameterName, Timestamp x)
        throws SQLException
    {
        getOriginal().setTimestamp(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setAsciiStream(String parameterName, InputStream x, int length)
        throws SQLException
    {
        getOriginal().setAsciiStream(parameterName, x, length);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setBinaryStream(String parameterName, InputStream x, int length)
        throws SQLException
    {
        getOriginal().setBinaryStream(parameterName, x, length);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setObject(String parameterName, Object x, int targetSqlType, int scale)
        throws SQLException
    {
        getOriginal().setObject(parameterName, x, targetSqlType, scale);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setObject(String parameterName, Object x, int targetSqlType)
        throws SQLException
    {
        getOriginal().setObject(parameterName, x, targetSqlType);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setObject(String parameterName, Object x)
        throws SQLException
    {
        getOriginal().setObject(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setCharacterStream(String parameterName, Reader reader, int length)
        throws SQLException
    {
        getOriginal().setCharacterStream(parameterName, reader, length);
        handleStatementBind(parameterName, reader);
    }

    @Override
    public void setDate(String parameterName, Date x, Calendar cal)
        throws SQLException
    {
        getOriginal().setDate(parameterName, x, cal);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setTime(String parameterName, Time x, Calendar cal)
        throws SQLException
    {
        getOriginal().setTime(parameterName, x, cal);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setTimestamp(String parameterName, Timestamp x, Calendar cal)
        throws SQLException
    {
        getOriginal().setTimestamp(parameterName, x, cal);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setNull(String parameterName, int sqlType, String typeName)
        throws SQLException
    {
        getOriginal().setNull(parameterName, sqlType, typeName);
        handleStatementBind(parameterName, null);
    }

    @Override
    public String getString(String parameterName)
        throws SQLException
    {
        return getOriginal().getString(parameterName);
    }

    @Override
    public boolean getBoolean(String parameterName)
        throws SQLException
    {
        return getOriginal().getBoolean(parameterName);
    }

    @Override
    public byte getByte(String parameterName)
        throws SQLException
    {
        return getOriginal().getByte(parameterName);
    }

    @Override
    public short getShort(String parameterName)
        throws SQLException
    {
        return getOriginal().getShort(parameterName);
    }

    @Override
    public int getInt(String parameterName)
        throws SQLException
    {
        return getOriginal().getInt(parameterName);
    }

    @Override
    public long getLong(String parameterName)
        throws SQLException
    {
        return getOriginal().getLong(parameterName);
    }

    @Override
    public float getFloat(String parameterName)
        throws SQLException
    {
        return getOriginal().getFloat(parameterName);
    }

    @Override
    public double getDouble(String parameterName)
        throws SQLException
    {
        return getOriginal().getDouble(parameterName);
    }

    @Override
    public byte[] getBytes(String parameterName)
        throws SQLException
    {
        return getOriginal().getBytes(parameterName);
    }

    @Override
    public Date getDate(String parameterName)
        throws SQLException
    {
        return getOriginal().getDate(parameterName);
    }

    @Override
    public Time getTime(String parameterName)
        throws SQLException
    {
        return getOriginal().getTime(parameterName);
    }

    @Override
    public Timestamp getTimestamp(String parameterName)
        throws SQLException
    {
        return getOriginal().getTimestamp(parameterName);
    }

    @Override
    public Object getObject(String parameterName)
        throws SQLException
    {
        return getOriginal().getObject(parameterName);
    }

    @Override
    public BigDecimal getBigDecimal(String parameterName)
        throws SQLException
    {
        return getOriginal().getBigDecimal(parameterName);
    }

    @Override
    public Object getObject(String parameterName, Map<String, Class<?>> map)
        throws SQLException
    {
        return getOriginal().getObject(parameterName, map);
    }

    @Override
    public Ref getRef(String parameterName)
        throws SQLException
    {
        return getOriginal().getRef(parameterName);
    }

    @Override
    public Blob getBlob(String parameterName)
        throws SQLException
    {
        return getOriginal().getBlob(parameterName);
    }

    @Override
    public Clob getClob(String parameterName)
        throws SQLException
    {
        return getOriginal().getClob(parameterName);
    }

    @Override
    public Array getArray(String parameterName)
        throws SQLException
    {
        return getOriginal().getArray(parameterName);
    }

    @Override
    public Date getDate(String parameterName, Calendar cal)
        throws SQLException
    {
        return getOriginal().getDate(parameterName, cal);
    }

    @Override
    public Time getTime(String parameterName, Calendar cal)
        throws SQLException
    {
        return getOriginal().getTime(parameterName, cal);
    }

    @Override
    public Timestamp getTimestamp(String parameterName, Calendar cal)
        throws SQLException
    {
        return getOriginal().getTimestamp(parameterName, cal);
    }

    @Override
    public URL getURL(String parameterName)
        throws SQLException
    {
        return getOriginal().getURL(parameterName);
    }

    @Override
    public RowId getRowId(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getRowId(parameterIndex);
    }

    @Override
    public RowId getRowId(String parameterName)
        throws SQLException
    {
        return getOriginal().getRowId(parameterName);
    }

    @Override
    public void setRowId(String parameterName, RowId x)
        throws SQLException
    {
        getOriginal().setRowId(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setNString(String parameterName, String value)
        throws SQLException
    {
        getOriginal().setNString(parameterName, value);
        handleStatementBind(parameterName, value);
    }

    @Override
    public void setNCharacterStream(String parameterName, Reader value, long length)
        throws SQLException
    {
        getOriginal().setNCharacterStream(parameterName, value, length);
        handleStatementBind(parameterName, value);
    }

    @Override
    public void setNClob(String parameterName, NClob value)
        throws SQLException
    {
        getOriginal().setNClob(parameterName, value);
        handleStatementBind(parameterName, value);
    }

    @Override
    public void setClob(String parameterName, Reader reader, long length)
        throws SQLException
    {
        getOriginal().setClob(parameterName, reader, length);
        handleStatementBind(parameterName, reader);
    }

    @Override
    public void setBlob(String parameterName, InputStream inputStream, long length)
        throws SQLException
    {
        getOriginal().setBlob(parameterName, inputStream, length);
        handleStatementBind(parameterName, inputStream);
    }

    @Override
    public void setNClob(String parameterName, Reader reader, long length)
        throws SQLException
    {
        getOriginal().setNClob(parameterName, reader, length);
        handleStatementBind(parameterName, reader);
    }

    @Override
    public NClob getNClob(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getNClob(parameterIndex);
    }

    @Override
    public NClob getNClob(String parameterName)
        throws SQLException
    {
        return getOriginal().getNClob(parameterName);
    }

    @Override
    public void setSQLXML(String parameterName, SQLXML xmlObject)
        throws SQLException
    {
        getOriginal().setSQLXML(parameterName, xmlObject);
        handleStatementBind(parameterName, xmlObject);
    }

    @Override
    public SQLXML getSQLXML(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getSQLXML(parameterIndex);
    }

    @Override
    public SQLXML getSQLXML(String parameterName)
        throws SQLException
    {
        return getOriginal().getSQLXML(parameterName);
    }

    @Override
    public String getNString(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getNString(parameterIndex);
    }

    @Override
    public String getNString(String parameterName)
        throws SQLException
    {
        return getOriginal().getNString(parameterName);
    }

    @Override
    public Reader getNCharacterStream(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getNCharacterStream(parameterIndex);
    }

    @Override
    public Reader getNCharacterStream(String parameterName)
        throws SQLException
    {
        return getOriginal().getNCharacterStream(parameterName);
    }

    @Override
    public Reader getCharacterStream(int parameterIndex)
        throws SQLException
    {
        return getOriginal().getCharacterStream(parameterIndex);
    }

    @Override
    public Reader getCharacterStream(String parameterName)
        throws SQLException
    {
        return getOriginal().getCharacterStream(parameterName);
    }

    @Override
    public void setBlob(String parameterName, Blob x)
        throws SQLException
    {
        getOriginal().setBlob(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setClob(String parameterName, Clob x)
        throws SQLException
    {
        getOriginal().setClob(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setAsciiStream(String parameterName, InputStream x, long length)
        throws SQLException
    {
        getOriginal().setAsciiStream(parameterName, x, length);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setBinaryStream(String parameterName, InputStream x, long length)
        throws SQLException
    {
        getOriginal().setBinaryStream(parameterName, x, length);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setCharacterStream(String parameterName, Reader reader, long length)
        throws SQLException
    {
        getOriginal().setCharacterStream(parameterName, reader, length);
        handleStatementBind(parameterName, reader);
    }

    @Override
    public void setAsciiStream(String parameterName, InputStream x)
        throws SQLException
    {
        getOriginal().setAsciiStream(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setBinaryStream(String parameterName, InputStream x)
        throws SQLException
    {
        getOriginal().setBinaryStream(parameterName, x);
        handleStatementBind(parameterName, x);
    }

    @Override
    public void setCharacterStream(String parameterName, Reader reader)
        throws SQLException
    {
        getOriginal().setCharacterStream(parameterName, reader);
        handleStatementBind(parameterName, reader);
    }

    @Override
    public void setNCharacterStream(String parameterName, Reader value)
        throws SQLException
    {
        getOriginal().setNCharacterStream(parameterName, value);
        handleStatementBind(parameterName, value);
    }

    @Override
    public void setClob(String parameterName, Reader reader)
        throws SQLException
    {
        getOriginal().setClob(parameterName, reader);
        handleStatementBind(parameterName, reader);
    }

    @Override
    public void setBlob(String parameterName, InputStream inputStream)
        throws SQLException
    {
        getOriginal().setBlob(parameterName, inputStream);
        handleStatementBind(parameterName, inputStream);
    }

    @Override
    public void setNClob(String parameterName, Reader reader)
        throws SQLException
    {
        getOriginal().setNClob(parameterName, reader);
        handleStatementBind(parameterName, reader);
    }

    @Override
    public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException {
        return getOriginal().getObject(parameterIndex, type);
    }

    @Override
    public <T> T getObject(String parameterName, Class<T> type) throws SQLException {
        return getOriginal().getObject(parameterName, type);
    }

}


text:
/*
 * Module Name: VMware Certificate Server
 *
 * Filename: globals.c
 *
 * Abstract:
 *
 * VMware Certificate Server Database
 *
 * Globals
 *
 */

#include "includes.h"

VMCA_DB_GLOBALS gVmcaDbGlobals =
    {
        PTHREAD_MUTEX_INITIALIZER,
	NULL,
        VMCA_DB_MAX_NUM_CACHED_CONTEXTS,
        0,
        NULL
    };


text:
var categoryFactory = require('./category-factory.service');

module.exports = angular.module('svc.category', [
])
.factory(categoryFactory.name, categoryFactory)
.name;


text:
<?php

namespace AdrianMejias\ZipBomb\Test;

use Orchestra\Testbench\TestCase as Orchestra;

class TestCase extends Orchestra
{
    public function setUp()
    {
        parent::setUp();
    }
}


text:
ntp
===

puppet ntp module for ubuntu


text:
<?php

namespace Itslearning\Client\Interceptors;

use SoapHeader;
use SoapVar;
use stdClass;

abstract class AuthenticationInterceptor implements Interceptor
{

    const NAMESPACE = 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd';
    const CONTAINER = 'Security';

    /**
     * @param string $username
     * @param string $password
     * @return SoapHeader
     */
    protected function toHeader(string $username, string $password):SoapHeader
    {
        $wsseAuth = new stdClass;
        $wsseAuth->Username = new SoapVar($username, XSD_STRING, null, self::NAMESPACE, null, self::NAMESPACE);
        $wsseAuth->Password = new SoapVar($password, XSD_STRING, null, self::NAMESPACE, null, self::NAMESPACE);

        $usernameToken = new SoapVar($wsseAuth, SOAP_ENC_OBJECT, null, self::NAMESPACE, 'UsernameToken',
            self::NAMESPACE);

        $wsseToken = new stdClass();
        $wsseToken->UsernameToken = $usernameToken;

        $objSoapVarWSSEToken = new SoapVar(
            $wsseToken,
            SOAP_ENC_OBJECT,
            null,
            self::NAMESPACE,
            'UsernameToken',
            self::NAMESPACE
        );

        $header = new SoapVar(
            $objSoapVarWSSEToken,
            SOAP_ENC_OBJECT,
            null,
            self::NAMESPACE,
            self::CONTAINER,
            self::NAMESPACE
        );

        return new SoapHeader(self::NAMESPACE, self::CONTAINER, $header);
    }
}


text:
#pragma once
#include <aws/apigateway/APIGateway_EXPORTS.h>
#include <aws/apigateway/APIGatewayRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>

namespace Aws
{
namespace APIGateway
{
namespace Model
{

  /**
   *
Request to describe an existing Authorizer resource.

See
   * Also:
   AWS
   * API Reference

   */
  class AWS_APIGATEWAY_API GetAuthorizerRequest : public APIGatewayRequest
  {
  public:
    GetAuthorizerRequest();

    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "GetAuthorizer"; }

    Aws::String SerializePayload() const override;

    /**
     *
[Required] The string identifier of the associated RestApi.

     */
    inline const Aws::String& GetRestApiId() const{ return m_restApiId; }

    /**
     *
[Required] The string identifier of the associated RestApi.

     */
    inline bool RestApiIdHasBeenSet() const { return m_restApiIdHasBeenSet; }

    /**
     *
[Required] The string identifier of the associated RestApi.

     */
    inline void SetRestApiId(const Aws::String& value) { m_restApiIdHasBeenSet = true; m_restApiId = value; }

    /**
     *
[Required] The string identifier of the associated RestApi.

     */
    inline void SetRestApiId(Aws::String&& value) { m_restApiIdHasBeenSet = true; m_restApiId = std::move(value); }

    /**
     *
[Required] The string identifier of the associated RestApi.

     */
    inline void SetRestApiId(const char* value) { m_restApiIdHasBeenSet = true; m_restApiId.assign(value); }

    /**
     *
[Required] The string identifier of the associated RestApi.

     */
    inline GetAuthorizerRequest& WithRestApiId(const Aws::String& value) { SetRestApiId(value); return *this;}

    /**
     *
[Required] The string identifier of the associated RestApi.

     */
    inline GetAuthorizerRequest& WithRestApiId(Aws::String&& value) { SetRestApiId(std::move(value)); return *this;}

    /**
     *
[Required] The string identifier of the associated RestApi.

     */
    inline GetAuthorizerRequest& WithRestApiId(const char* value) { SetRestApiId(value); return *this;}

    /**
     *
[Required] The identifier of the Authorizer resource.

     */
    inline const Aws::String& GetAuthorizerId() const{ return m_authorizerId; }

    /**
     *
[Required] The identifier of the Authorizer resource.

     */
    inline bool AuthorizerIdHasBeenSet() const { return m_authorizerIdHasBeenSet; }

    /**
     *
[Required] The identifier of the Authorizer resource.

     */
    inline void SetAuthorizerId(const Aws::String& value) { m_authorizerIdHasBeenSet = true; m_authorizerId = value; }

    /**
     *
[Required] The identifier of the Authorizer resource.

     */
    inline void SetAuthorizerId(Aws::String&& value) { m_authorizerIdHasBeenSet = true; m_authorizerId = std::move(value); }

    /**
     *
[Required] The identifier of the Authorizer resource.

     */
    inline void SetAuthorizerId(const char* value) { m_authorizerIdHasBeenSet = true; m_authorizerId.assign(value); }

    /**
     *
[Required] The identifier of the Authorizer resource.

     */
    inline GetAuthorizerRequest& WithAuthorizerId(const Aws::String& value) { SetAuthorizerId(value); return *this;}

    /**
     *
[Required] The identifier of the Authorizer resource.

     */
    inline GetAuthorizerRequest& WithAuthorizerId(Aws::String&& value) { SetAuthorizerId(std::move(value)); return *this;}

    /**
     *
[Required] The identifier of the Authorizer resource.

     */
    inline GetAuthorizerRequest& WithAuthorizerId(const char* value) { SetAuthorizerId(value); return *this;}

  private:

    Aws::String m_restApiId;
    bool m_restApiIdHasBeenSet;

    Aws::String m_authorizerId;
    bool m_authorizerIdHasBeenSet;
  };

} // namespace Model
} // namespace APIGateway
} // namespace Aws


text:
@interface SceneComponent : NSObject {
	NSString *name;
	NSString *filename;
	CCSprite *sprite;
	NSMutableArray *startTranslateAnimations;
	NSMutableArray *clickTranslateAnimations;
	NSMutableArray *startFrameAnimations;
	NSMutableArray *clickFrameAnimations;
	CCNode *node;
	int z;
	int isAnimating;
	BOOL interactiveDuringIntro;
	NSArray *animationTrigger;
	int triggerState;
	BOOL isSmoke;
	BOOL hasSound;
	CGRect clickBox;
	BOOL clickable;
}

@property(readonly) NSString *name;
@property(readonly) NSString *filename;
@property(readonly) int z;

+(id) componentWithDictionary:(NSDictionary *)dict:(int)tag;

-(id) initWithDictionary:(NSDictionary *)dict:(int)tag;
-(void) runStartAnimations;
-(CCNode *) getCocosNode;
-(void) stopAnimations;
-(BOOL) handleTouch:(CGPoint)point;
-(void)triggerAnimations;
-(BOOL) isTouched:(CGPoint)point;
-(void) animationDone;
-(void) killAnimations;

@end


text:
package com.belatrixsf.connect.ui.skills;

import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.Nullable;

import com.belatrixsf.connect.R;
import com.belatrixsf.connect.ui.common.BelatrixConnectActivity;

/**
 * Created by echuquilin on 4/08/16.
 */
public class SkillsListActivity extends BelatrixConnectActivity{

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_base);
        setNavigationToolbar();
        if (savedInstanceState == null) {
            replaceFragment(SkillsListFragment.newInstance(), false);
        }
    }

    public static Intent makeIntent(Context context) {
        return new Intent(context, SkillsListActivity.class);
    }

}


text:
'use strict';

var path = require('path');
var fs = require('fs');

var WebidaFS = require('../webidafs').WebidaFS;

function createFS(fsid, callback) {
    var rootPath = (new WebidaFS(fsid)).getRootPath();
    fs.mkdir(rootPath, callback);
}
exports.createFS = createFS;

function deleteFS(fsid, callback) {
    // Do nothing here and remove it from batch job
    callback();
}
exports.deleteFS = deleteFS;

function doesSupportQuota() {
    return false;
}
exports.doesSupportQuota = doesSupportQuota;

function getQuotaInfo(fsid, callback) {
    callback(new Error('Unsupported feature'));
}
exports.getQuotaInfo = getQuotaInfo;

function getQuotaLimit(fsid, callback) {
    callback(new Error('Unsupported feature'));
}
exports.getQuotaLimit = getQuotaLimit;

function setQuotaLimit(fsid, callback) {
    callback(new Error('Unsupported feature'));
}
exports.setQuotaLimit = setQuotaLimit;

function getQuotaUsage(fsid, callback) {
    callback(new Error('Unsupported feature'));
}
exports.getQuotaUsage = getQuotaUsage;


text:
#import <UIKit/UIKit.h>
#import "BITStoreButton.h"

typedef enum {
	AppStoreButtonStateOffline,
	AppStoreButtonStateCheck,
	AppStoreButtonStateSearching,
	AppStoreButtonStateUpdate,
	AppStoreButtonStateInstalling
} AppStoreButtonState;

@class BITUpdateManager;

@protocol PSStoreButtonDelegate;

@interface BITUpdateViewController() <BITStoreButtonDelegate> {
}

@property (nonatomic, weak) BITUpdateManager *updateManager;
@property (nonatomic, readwrite) BOOL modal;

@property (nonatomic, assign) AppStoreButtonState appStoreButtonState;

@end


text:
pkg = resource.package.new("redis")
pkg.state = "present"

-- Start Redis service
svc = resource.service.new("redis")
svc.state = "running"
svc.enable = true
svc.require = {
  pkg:ID(),

}

-- To access Redis
print("access redis using redis-cli")

-- Finally, register the resources to the catalog
catalog:add(pkg, systemd_reload, svc)


text:
A JavaScript Library. Provides communication flow for your program systems.

Inspired by ["A Mathematical Theory of Communication"][1].

## Why?

Data management layer and view layer can be rewritten with new library, but communication flow will be the same.

## Ideas

 * Functional infrastructure
 * Unidirectional data flow
 * Declarative style

## Questions

 * What I'm trying to build?
 * What types of web pages will be supported by Shannon? (content pages, statefull apps)
 * How many instances can app has to stay simple? (2, 3)
 * How can we describe a protocol in communication system between app and user?
 * What about 3rd party libs for rendering and data persistance?
 * How can we manage a complex state of systems?
   * Is it possible to use only attrs for dynamic components?
 * Is it possible to abstract store instance to server implementation?
 * We need some way to distinguish type of communication between components (react or interact).
 * Can we reuse whole app screen as a component?
 * We should have [explicit][6] state management
  * State management based on client's events is simply [reducing initial state](https://github.com/staltz/mvi-example/blob/master/src/models/items.js)

## License

MIT License

 [1]: http://cm.bell-labs.com/cm/ms/what/shannonday/shannon1948.pdf
 [2]: http://www.eden-study.org/articles/2006/abstraction-classes-sw-design_ieesw.pdf
 [3]: http://conal.net/papers/push-pull-frp/push-pull-frp.pdf
 [4]: http://shaffner.us/cs/papers/tarpit.pdf
 [5]: http://en.wikipedia.org/wiki/Control_theory
 [6]: https://www.youtube.com/watch?v=5yHFTN-_mOo


text:
import logging
import threading

import gtk
import gobject
import pkgutil

from ..app_context import get_app
from logging_helpers import _L  #: .. versionadded:: 2.20
from ..plugin_manager import get_service_instance_by_name

logger = logging.getLogger(__name__)

class PluginManagerDialog(object):
    '''
    List installed plugins with the following action buttons for each plugin:

     - Enable
     - Disable
     - **TODO** Uninstall
    '''
    def __init__(self):
        '''
        .. versionchanged:: 2.21
            Read glade file using ``pkgutil`` to also support loading from
            ``.zip`` files (e.g., in app packaged with Py2Exe).
        '''
        builder = gtk.Builder()
        # Read glade file using `pkgutil` to also support loading from `.zip`
        # files (e.g., in app packaged with Py2Exe).
        glade_str = pkgutil.get_data(__name__,
                                     'glade/plugin_manager_dialog.glade')
        builder.add_from_string(glade_str)

        self.window = builder.get_object('plugin_manager')
        self.vbox_plugins = builder.get_object('vbox_plugins')
        builder.connect_signals(self)

    def clear_plugin_list(self):
        self.vbox_plugins.foreach(lambda x: self.vbox_plugins.remove(x))

    @property
    def controller(self):
        plugin_name = 'microdrop.gui.plugin_manager_controller'
        service = get_service_instance_by_name(plugin_name, env='microdrop')
        return service

    def update(self):
        '''
        Update plugin list widget.
        '''
        self.clear_plugin_list()
        self.controller.update()
        for p in self.controller.plugins:
            self.vbox_plugins.pack_start(p.get_widget())

    def run(self):
        '''
        .. versionchanged:: 2.10.3
            Use :func:`plugin_helpers.get_plugin_info` function to retrieve
            package name.

        .. versionchanged:: 2.10.5
            Save Python module names of enabled plugins (**not** Conda package
            names) to ``microdrop.ini`` configuration file.
        '''
        # TODO
        # ----
        #
        #  - [ ] Remove all references to `app`
        #  - [ ] Use `MICRODROP_CONDA_ETC/plugins/enabled` to maintain enabled
        #    plugin references instead of MicroDrop profile `microdrop.ini`
        app = get_app()
        self.update()
        response = self.window.run()
        self.window.hide()
        for p in self.controller.plugins:
            package_name = p.get_plugin_info().package_name
            # Extract importable Python module name from Conda package name.
            #
            # XXX Plugins are currently Python modules, which means that the
            # installed plugin directory must be a valid module name. However,
            # Conda package name conventions may include `.` and `-`
            # characters.
            module_name = package_name.split('.')[-1].replace('-', '_')
            if p.enabled():
                if module_name not in app.config["plugins"]["enabled"]:
                    app.config["plugins"]["enabled"].append(module_name)
            else:
                if module_name in app.config["plugins"]["enabled"]:
                    app.config["plugins"]["enabled"].remove(module_name)
        app.config.save()
        if self.controller.restart_required:
            _L().warning('\n'.join(['Plugins and/or dependencies were '
                                    'installed/uninstalled.',
                                    'Program needs to be restarted for '
                                    'changes to take effect.']))
            # Use return code of `5` to signal program should be restarted.
            app.main_window_controller.on_destroy(None, return_code=5)
            return response
        return response

if __name__ == '__main__':
    pm = PluginManagerDialog()


text:
"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

exports.__esModule = true;
exports.createDbQueriesFromObject = createDbQueriesFromObject;
exports.prefixResolvedFields = prefixResolvedFields;
exports.dbQueryToSiftQuery = dbQueryToSiftQuery;
exports.toDottedFields = toDottedFields;
exports.objectToDottedField = objectToDottedField;
exports.liftResolvedFields = liftResolvedFields;
exports.DbComparator = void 0;

var _ = _interopRequireWildcard(require("lodash"));

let DbComparator;
exports.DbComparator = DbComparator;

(function (DbComparator) {
  DbComparator["EQ"] = "$eq";
  DbComparator["NE"] = "$ne";
  DbComparator["GT"] = "$gt";
  DbComparator["GTE"] = "$gte";
  DbComparator["LT"] = "$lt";
  DbComparator["LTE"] = "$lte";
  DbComparator["IN"] = "$in";
  DbComparator["NIN"] = "$nin";
  DbComparator["REGEX"] = "$regex";
  DbComparator["GLOB"] = "$glob";
})(DbComparator || (exports.DbComparator = DbComparator = {}));

const DB_COMPARATOR_VALUES = new Set(Object.values(DbComparator));

function isDbComparator(value) {
  return DB_COMPARATOR_VALUES.has(value);
}

/**
 * Converts a nested mongo args object into array of DbQuery objects,
 * structured representation of each distinct path of the query. We convert
 * nested objects with multiple keys to separate instances.
 */
function createDbQueriesFromObject(filter) {
  return createDbQueriesFromObjectNested(filter);
}

function createDbQueriesFromObjectNested(filter, path = []) {
  const keys = Object.getOwnPropertyNames(filter);
  return _.flatMap(keys, key => {
    if (key === `$elemMatch`) {
      const queries = createDbQueriesFromObjectNested(filter[key]);
      return queries.map(query => {
        return {
          type: `elemMatch`,
          path: path,
          nestedQuery: query
        };
      });
    } else if (isDbComparator(key)) {
      return [{
        type: `query`,
        path,
        query: {
          comparator: key,
          value: filter[key]
        }
      }];
    } else {
      return createDbQueriesFromObjectNested(filter[key], path.concat([key]));
    }
  });
}

function prefixResolvedFields(queries, resolvedFields) {
  const dottedFields = objectToDottedField(resolvedFields);
  const dottedFieldKeys = Object.getOwnPropertyNames(dottedFields);
  queries.forEach(query => {
    const prefixPath = query.path.join(`.`);

    if (dottedFields[prefixPath] || dottedFieldKeys.some(dottedKey => dottedKey.startsWith(prefixPath)) && query.type === `elemMatch` || dottedFieldKeys.some(dottedKey => prefixPath.startsWith(dottedKey))) {
      query.path.unshift(`__gatsby_resolved`);
    }
  });
  return queries;
}

function dbQueryToSiftQuery(query) {
  const result = {};

  if (query.type === `elemMatch`) {
    result[query.path.join(`.`)] = {
      $elemMatch: dbQueryToSiftQuery(query.nestedQuery)
    };
  } else if (query.path.length) {
    result[query.path.join(`.`)] = {
      [query.query.comparator]: query.query.value
    };
  } else {
    return {
      [query.query.comparator]: query.query.value
    };
  }

  return result;
} // Most of the below can be gone after we decide to remove loki
// Converts a nested mongo args object into a dotted notation. acc
// (accumulator) must be a reference to an empty object. The converted
// fields will be added to it. E.g
//
// {
//   internal: {
//     type: {
//       $eq: "TestNode"
//     },
//     content: {
//       $regex: new MiniMatch(v)
//     }
//   },
//   id: {
//     $regex: newMiniMatch(v)
//   }
// }
//
// After execution, acc would be:
//
// {
//   "internal.type": {
//     $eq: "TestNode"
//   },
//   "internal.content": {
//     $regex: new MiniMatch(v)
//   },
//   "id": {
//     $regex: // as above
//   }
// }

function toDottedFields(filter, acc = {}, path = []) {
  Object.keys(filter).forEach(key => {
    const value = filter[key];
    const nextValue = _.isPlainObject(value) && value[Object.keys(value)[0]];

    if (key === `$elemMatch`) {
      acc[path.join(`.`)] = {
        [`$elemMatch`]: toDottedFields(value)
      };
    } else if (_.isPlainObject(nextValue)) {
      toDottedFields(value, acc, path.concat(key));
    } else {
      acc[path.concat(key).join(`.`)] = value;
    }
  });
  return acc;
} // Like above, but doesn't handle $elemMatch

function objectToDottedField(obj, path = []) {
  let result = {};
  Object.keys(obj).forEach(key => {
    const value = obj[key];

    if (_.isPlainObject(value)) {
      const pathResult = objectToDottedField(value, path.concat(key));
      result = { ...result,
        ...pathResult
      };
    } else {
      result[path.concat(key).join(`.`)] = value;
    }
  });
  return result;
}

function liftResolvedFields(args, resolvedFields) {
  const dottedFields = objectToDottedField(resolvedFields);
  const dottedFieldKeys = Object.keys(dottedFields);
  const finalArgs = {};
  Object.keys(args).forEach(key => {
    const value = args[key];

    if (dottedFields[key]) {
      finalArgs[`__gatsby_resolved.${key}`] = value;
    } else if (dottedFieldKeys.some(dottedKey => dottedKey.startsWith(key)) && value.$elemMatch) {
      finalArgs[`__gatsby_resolved.${key}`] = value;
    } else if (dottedFieldKeys.some(dottedKey => key.startsWith(dottedKey))) {
      finalArgs[`__gatsby_resolved.${key}`] = value;
    } else {
      finalArgs[key] = value;
    }
  });
  return finalArgs;
}
//# sourceMappingURL=query.js.map


text:
namespace ftypes
{
enum class RoadShieldType
{
  Default = 0,
  Generic_White,  // The same as default, for semantics
  Generic_Green,
  Generic_Blue,
  Generic_Red,
  Generic_Orange,
  US_Interstate,
  US_Highway,
  UK_Highway,
  Hidden,
  Count
};

struct RoadShield
{
  RoadShieldType m_type;
  std::string m_name;
  std::string m_additionalText;

  RoadShield() = default;
  RoadShield(RoadShieldType const & type, std::string const & name)
  : m_type(type), m_name(name)
  {}
  RoadShield(RoadShieldType const & type, std::string const & name,
             std::string const & additionalText)
  : m_type(type), m_name(name), m_additionalText(additionalText)
  {}

  inline bool operator<(RoadShield const & other) const
  {
    if (m_additionalText == other.m_additionalText)
    {
      if (m_type == other.m_type)
        return m_name < other.m_name;
      return m_type < other.m_type;
    }
    return m_additionalText < other.m_additionalText;
  }
};

std::set<RoadShield> GetRoadShields(FeatureType & f);
std::string DebugPrint(RoadShieldType shieldType);
std::string DebugPrint(RoadShield const & shield);
}  // namespace ftypes

using GeneratedRoadShields = std::map<ftypes::RoadShield, std::vector<m2::RectD>>;


text:
#ifndef I2C_TESTER_H
#define I2C_TESTER_H

#include "MbedTester.h"

class I2CTester: public MbedTester {
public:

    I2CTester(const PinList *form_factor, const PinList *exclude_pins)
        : MbedTester(form_factor, exclude_pins)
    {

    }

    /* **I2C peripheral functions** */

    /**
     * Get the number of start conditions since last I2C reset
     *
     * @return The number of start conditions
     */
    uint8_t num_starts();

    /**
     * Get the number of stop conditions since last I2C reset
     *
     * @return The number of stop conditions
     */
    uint8_t num_stops();

    /**
     * Get the number of ACKs since last I2C reset
     *
     * @return The number of ACKs
     */
    uint16_t num_acks();

    /**
     * Get the number of NACKs since last I2C reset
     *
     * @return The number of NACKs
     */
    uint16_t num_nacks();

    /**
     * Read the number of transfers which have occurred
     *
     * @return The number of I2C transfers that have completed since
     *         i2c was reset, including the device address byte.
     */
    uint16_t transfer_count();

    /**
     * Read a checksum of data send to the tester
     *
     * @return The sum of all bytes sent to the tester since reset
     */
    uint32_t get_receive_checksum();

    /**
     * Read a checksum the tester calculated for data it has already sent
     *
     * @return The sum of all bytes the tester has sent since reset
     */
    uint32_t get_send_checksum();

    /**
     * Get the I2C slave state number
     *
     * @return The state number
     */
    uint8_t state_num();

    /**
     * Get the number of times the device address has been sent correctly
     *
     * @return The number of times the device address has been sent correctly
     */
    uint8_t num_dev_addr_matches();

    /**
     * Get the number of times the device address has been sent incorrectly
     *
     * @return The number of times the device address has been sent incorrectly
     */
    uint8_t num_dev_addr_mismatches();

    /**
     * Set the I2C slave device address
     *
     * @param addr New address for slave device
     */
    void set_device_address(uint16_t addr);

    /**
     * Get the I2C slave device address
     *
     * @return The slave device address
     */
    uint16_t get_device_address();

    /**
     * Set SDA (test mode)
     *
     * @param value Test value for SDA
     */
    void set_sda(uint8_t value);

    /**
     * Get the value written to slave in the fourth to last transaction
     *
     * @return value written to slave in the fourth to last transaction
     */
    uint8_t get_prev_to_slave_4();

    /**
     * Get the value written to slave in the third to last transaction
     *
     * @return value written to slave in the third to last transaction
     */
    uint8_t get_prev_to_slave_3();

    /**
     * Get the value written to slave in the second to last transaction
     *
     * @return value written to slave in the second to last transaction
     */
    uint8_t get_prev_to_slave_2();

    /**
     * Get the value written to slave in the last transaction
     *
     * @return value written to slave in the last transaction
     */
    uint8_t get_prev_to_slave_1();

    /**
     * Set the value to be read from slave in next read transaction
     *
     * @param value Value to be read from slave in next read transaction
     */
    void set_next_from_slave(uint8_t value);

    /**
     * Get the value to be read from slave in next read transaction
     *
     * @return Value to be read from slave in next read transaction
     */
    uint8_t get_next_from_slave();

    /**
     * Read the number of writes which have occurred
     *
     * @return The number of I2C writes that have completed since
     *         i2c was reset, not including the device address byte
     */
    uint16_t num_writes();

    /**
     * Read the number of reads which have occurred
     *
     * @return The number of I2C reads that have completed since
     *         i2c was reset, not including the device address byte
     */
    uint16_t num_reads();

};

#endif


text:
/* ====================================================================
 * ====================================================================
 *
 *  Module: ti_bundle.h
 *  $Revision: 1.1 $
 *  $Date: 2001/10/30 16:59:45 $
 *  $Author: ciancu $
 *  $Source: bitbucket.org:berkeleylab/upc-translator.git/open64/osprey1.0/common/targ_info/access/ti_bundle.h $
 *
 *  Synopsis:
 *
 *      Bundle (or template) accounting package for various clients including
 *	the software pipeliner, local (BB) scheduler, disassembler and
 *      linker.
 *
 *  Interface Description:
 *
 *	Exported types:
 *
 *      Exported functions:
 *
 *	    BOOL TI_BUNDLE_Has_Property(
 *		TI_BUNDLE *bundle
 *		ISA_EXEC_UNIT_PROPERTY property
 *              INT *error
 *	    )
 *
 *		Returns TRUE if <bundle> contains an instance of <property>.
 *              If an error occurs, <error> is set to TI_RC_ERROR.
 *
 *	    BOOL TI_BUNDLE_Is_Full(
 *		TI_BUNDLE *bundle
 *              INT *error
 *	    )
 *
 *		Returns TRUE if <bundle> is fully packed with insts. If
 *              an error occurs, <error> is set to TI_RC_ERROR.
 *
 *	    BOOL TI_BUNDLE_Is_Empty(
 *		TI_BUNDLE *bundle
 *              INT *error
 *	    )
 *
 *		Returns TRUE if <bundle> is empty. If an error occurs,
 *		<error> is set to TI_RC_ERROR.
 *
 *          INT TI_BUNDLE_Return_Template(
 *              TI_BUNDLE *bundle
 *          )
 *
 *              Returns the template encoding bit for the slot pattern in
 *              <bundle>.
 *
 *          void TI_BUNDLE_Clear(
 *              TI_BUNDLE *bundle
 *          )
 *
 *              Reset the contents of the bundle.
 *
 *	    BOOL TI_BUNDLE_Slot_Available(
 *		TI_BUNDLE  *bundle
 *		ISA_EXEC_UNIT_PROPERTY  property
 *		INT slot
 *	    )
 *
 *              Check to see if 'slot' for 'property' is available for
 *		the given 'bundle'. Returns TRUE if available; FALSE
 *		otherwise.
 *
 *	    BOOL TI_BUNDLE_Stop_Bit_Available(
 *		TI_BUNDLE  *bundle
 *		INT slot
 *	    )
 *
 *              Check to see if a stop bit can be set for 'slot'
 *		in the given 'bundle'. Returns TRUE if available; FALSE
 *		otherwise.
 *
 *	    void TI_BUNDLE_Reserve_Slot(
 *		TI_BUNDLE  *bundle
 *		INT        slot
 *              ISA_EXEC_UNIT_PROPERTY property
 *	    )
 *
 *              Reserve 'slot' for 'property' at the given 'bundle'.
 *
 *	    void TI_BUNDLE_Reserve_Stop_Bit(
 *		TI_BUNDLE  *bundle
 *		INT        slot
 *	    )
 *
 *              Reserve 'slot' position for STOP bit at the given 'bundle'.
 *
 *	    void TI_BUNDLE_Unreserve_Stop_Bit(
 *		TI_BUNDLE  *bundle
 *		INT        slot
 *	    )
 *
 *              Unreserve 'slot' position for STOP bit at the given 'bundle'.
 *
 *
 * ====================================================================
 * ====================================================================
 */

#ifndef ti_bundle_INCLUDED
#define ti_bundle_INCLUDED

#include "topcode.h"

#ifdef __cplusplus
extern "C" {
#endif

#ifdef _KEEP_RCS_ID
static const char ti_bundle_rcs_id[] = "$Source: bitbucket.org:berkeleylab/upc-translator.git/open64/osprey1.0/common/targ_info/access/ti_bundle.h $ $Revision: 1.1 $";
#endif /* _KEEP_RCS_ID */

#ifndef defs_INCLUDED
#define defs_INCLUDED
typedef signed int INT;
typedef signed int INT32;
typedef signed long long INT64;
typedef signed char mINT8;
typedef signed short mINT16;
typedef signed int mINT32;
typedef signed long long mINT64;
typedef unsigned int UINT;
typedef unsigned int UINT32;
typedef unsigned long long UINT64;
typedef unsigned char mUINT8;
typedef unsigned short mUINT16;
typedef unsigned int mUINT32;
typedef unsigned long long mUINT64;
typedef int BOOL;
typedef unsigned char mBOOL;
#ifndef TRUE
#define TRUE    ((BOOL) 1)
#endif
#ifndef FALSE
#define FALSE   ((BOOL) 0)
#endif
#if defined(_LANGUAGE_C) && !defined(inline)
#define inline static __inline
#endif
#endif

typedef struct ti_bundle {
  ISA_BUNDLE_INFO *bundle_info; /* exported interface from targ_info */
  BOOL slot_filled[ISA_MAX_SLOTS];
} TI_BUNDLE;

/* TI_BUNDLE accessors:
 */

#define TI_BUNDLE_bundle_info(t)            ((t)->bundle_info)
#define TI_BUNDLE_slot_count(t)             ((t)->bundle_info->slot_count)
#define TI_BUNDLE_exec_property(t,i)        ((t)->bundle_info->slot[i])
#define TI_BUNDLE_stop_bit(t,i)             ((t)->bundle_info->stop[i])
#define TI_BUNDLE_slot_filled(t,i)          ((t)->slot_filled[i])
#define TI_BUNDLE_slot_mask(t)              ((t)->bundle_info->slot_mask)
#define TI_BUNDLE_stop_mask(t)              ((t)->bundle_info->stop_mask)
#define TI_BUNDLE_pack_code(t)	    	    ((t)->bundle_info->pack_code)

#define Set_TI_BUNDLE_exec_property(t, i, value) ((t)->bundle_info->slot[i] = \
						  (value))
#define Set_TI_BUNDLE_slot_mask(t, i)       ((t)->bundle_info->slot_mask = i)
#define Set_TI_BUNDLE_stop_mask(t, i)       ((t)->bundle_info->stop_mask = i)
#define Set_TI_BUNDLE_slot_count(t, i)      ((t)->bundle_info->slot_count = i)
#define Set_TI_BUNDLE_stop_bit(t, i, value) ((t)->bundle_info->stop[i] = \
						  (value))
#define Set_TI_BUNDLE_pack_code(t, value)   ((t)->bundle_info->pack_code = \
    	    	    	    	    	    	  (value))

/* Iterator Macros */

#define FOR_ALL_SLOT_MEMBERS(bundle, i) \
     for (i = 0; i < TI_BUNDLE_slot_count(bundle); ++i)

inline BOOL
TI_BUNDLE_Stop_Bit_Present(TI_BUNDLE *bundle) {
  INT i;
  for (i = 0; i < TI_BUNDLE_slot_count(bundle) - 1; ++i) {
    if (TI_BUNDLE_stop_bit(bundle, i)) return TRUE;
  }
  return FALSE;
}

extern BOOL TI_BUNDLE_Has_Property(
  TI_BUNDLE *bundle,
  ISA_EXEC_UNIT_PROPERTY property,
  INT *error
);

extern BOOL TI_BUNDLE_Is_Full(
  TI_BUNDLE *bundle,
  INT *error
);

extern BOOL TI_BUNDLE_Is_Empty(
  TI_BUNDLE *bundle,
  INT *error
);

extern INT TI_BUNDLE_Return_Template(
  TI_BUNDLE *bundle
);

extern void TI_BUNDLE_Clear(
  TI_BUNDLE *bundle
);

extern BOOL TI_BUNDLE_Slot_Available(
  TI_BUNDLE  *bundle,
  ISA_EXEC_UNIT_PROPERTY  property,
  INT        slot
);

extern BOOL TI_BUNDLE_Stop_Bit_Available(
  TI_BUNDLE  *bundle,
  INT        slot
);

extern void TI_BUNDLE_Reserve_Slot(
  TI_BUNDLE  *bundle,
  INT slot,
  ISA_EXEC_UNIT_PROPERTY property
);

extern void TI_BUNDLE_Reserve_Stop_Bit(
  TI_BUNDLE  *bundle,
  INT slot
);

extern void TI_BUNDLE_Unreserve_Stop_Bit(
  TI_BUNDLE  *bundle,
  INT slot
);

#ifdef __cplusplus
}
#endif
#endif /* ti_res_res_INCLUDED */


text:
package com.studio4plus.homerplayer.model;

public class Position {
    public final String filePath;
    public final int seekPosition;

    public Position(String filePath, int seekPosition) {
        this.filePath = filePath;
        this.seekPosition = seekPosition;
    }
}


text:
using UnityEngine;
using UnityEngine.Audio;
using System.Collections;

public class AudioManager : Singleton<AudioManager>
{
    public AudioSource sfxSource;
    public AudioSource sharedSFXSource;
    public AudioSource musicSource1;
    public AudioSource musicSource2;
    public AudioSource uiSource;

    public float volumeIncrement = 0.1f;

    public float startingVolume = 0.8f;
    public float maxVolume = 1.0f;
    public float minVolume = 0.0f;

    public float musicFadeInTime = 2.0f;

    // Use this for initialization
    public override void Start()
    {
        base.Start();

        if (this == null) { return; }

        AudioListener.volume = startingVolume;

        StartMusic(musicSource1, 2.0f, true);
    }

    // Update is called once per frame
    void Update()
    {
        //if (Input.GetButtonDown("Raise Volume"))
        //{
        //    SetVolume(AudioListener.volume + volumeIncrement);
        //}

        //if (Input.GetButtonDown("Lower Volume"))
        //{
        //    SetVolume(AudioListener.volume - volumeIncrement);
        //}
    }

    public void StartGameMusic()
    {
        StartMusic(musicSource2, 0.5f, true);
        StopMusic(musicSource1, 0.5f);
    }

    public void SetVolume(float volume)
    {
        AudioListener.volume = Mathf.Clamp(volume, minVolume, maxVolume);
    }

    public void SetMusicVolume(float volume)
    {
        //musicSource1.volume = Mathf.Clamp(volume, minVolume, maxVolume);
    }

    public void StartMusic(AudioSource musicSource, float fadeInTime, bool restartIfPlaying)
    {
        if (musicSource.isPlaying)
        {
            if (!restartIfPlaying) { return; } //if we're already playing music, we don't need to start it

            musicSource.Stop();
        }

        StartCoroutine(DoStartMusic(musicSource, fadeInTime));
    }

    private IEnumerator DoStartMusic(AudioSource musicSource, float fadeInTime)
    {
        float startTime = Time.time;
        float elapsedTime = 0.0f;

        float targetVolume = musicSource.volume;
        musicSource.volume = 0.0f;
        musicSource.Play();

        while (elapsedTime < fadeInTime)
        {
            yield return new WaitForSeconds(0.1f);
            elapsedTime = Time.time - startTime;
            musicSource.volume = Mathf.Lerp(0.0f, targetVolume, elapsedTime / fadeInTime);
        }

        musicSource.volume = targetVolume;
    }

    public void StopMusic(AudioSource musicSource, float fadeOutTime)
    {
        if (musicSource.isPlaying)
        {
            StartCoroutine(DoStopMusic(musicSource, fadeOutTime));
        }
    }

    private IEnumerator DoStopMusic(AudioSource musicSource, float fadeOutTime)
    {
        float startTime = Time.time;
        float elapsedTime = 0.0f;

        float targetVolume = 0.0f;
        float startVolume = musicSource.volume;

        while (elapsedTime < fadeOutTime)
        {
            yield return new WaitForSeconds(0.1f);
            elapsedTime = Time.time - startTime;
            musicSource.volume = Mathf.Lerp(startVolume, targetVolume, elapsedTime / fadeOutTime);
        }

        musicSource.volume = targetVolume;
        musicSource.Stop();
    }

    public void PauseMusic(bool pause)
    {
        if (pause)
        {
            musicSource1.Pause();
        }
        else
        {
            musicSource1.UnPause();
        }
    }

    public void DuckMusic()
    {

    }

    public void UnduckMusic()
    {

    }

}


text:
Introduction
============

Philosophy
----------

This API is being developed with the following philosophy in mind.

#. Allow **fast** access to the entire database.
#. Make sensible default choices for the user (e.g., avoid high signal to noise ratio records).
#. Allow easy overriding of default choices.
#. To provide methods that are consistent across programming languages (e.g., Matlab, Python, R)
#. Follow the ideals of :pep:`20` as closely as possible.

.. _`mit`:

kiknetAPI License
-----------------

The MIT License (MIT)

Copyright (c) 2013 Shrey K. Shahi, Haitham Dawood, Adrian Rodriguez-Marek

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.


text:
import Component from '@glimmer/component';

export default class CodeBlockComponent extends Component {
  get language() {
    return this.args.language ?? 'markup';
  }

  get languageClass() {
    return `language-${this.language}`;
  }
}


text:
export interface ITreeOrgChartState {
  treeData: any;
  isLoading: boolean;
}


text:
struct edit_state_deps
{
	project_window_i* pw;
	edit_window_i*    ew;
	project_i*      project;
	selection_i*    selection;
};

class edit_state abstract
{
protected:
	project_window_i* const _pw;
	edit_window_i*    const _ew;
	project_i*        const _project;
	selection_i*      const _selection;

public:
	edit_state (const edit_state_deps& deps)
		: _pw(deps.pw), _ew(deps.ew), _selection(deps.selection), _project(deps.project)
	{ }

	virtual ~edit_state() { }
	virtual void process_mouse_button_down (edge::mouse_button button, UINT modifierKeysDown, const mouse_location& location) { }
	virtual void process_mouse_button_up   (edge::mouse_button button, UINT modifierKeysDown, const mouse_location& location) { }
	virtual void process_mouse_move (const mouse_location& location) { }
	virtual std::optional<LRESULT> process_key_or_syskey_down (UINT virtualKey, UINT modifierKeys) { return std::nullopt; }
	virtual std::optional<LRESULT> process_key_or_syskey_up   (UINT virtualKey, UINT modifierKeys) { return std::nullopt; }
	virtual void render (ID2D1DeviceContext* dc) { }
	virtual bool completed() const = 0;
	virtual HCURSOR cursor() const { return LoadCursor(nullptr, IDC_ARROW); }
};

std::unique_ptr<edit_state> create_state_move_bridges (const edit_state_deps& deps);
std::unique_ptr<edit_state> create_state_move_port (const edit_state_deps& deps);
std::unique_ptr<edit_state> create_state_create_bridge (const edit_state_deps& deps);
std::unique_ptr<edit_state> create_state_create_wire (const edit_state_deps& deps);
std::unique_ptr<edit_state> CreateStateMoveWirePoint (const edit_state_deps& deps, wire* wire, size_t pointIndex);
std::unique_ptr<edit_state> CreateStateBeginningDrag (const edit_state_deps& deps,
													 renderable_object* clickedObject,
													 edge::mouse_button button,
													 UINT modifierKeysDown,
													 const mouse_location& location,
													 HCURSOR cursor,
													 std::unique_ptr<edit_state>&& stateMoveThreshold,
													 std::unique_ptr<edit_state>&& stateButtonUp);


text:
using NUnit.Framework;
using System;

namespace MasterDevs.Core.Tests
{
    [TestFixture]
    public class CodeContractsTests
    {
        [Test]
        [ExpectedException(typeof(ArgumentNullException))]
        public void RequireHasValue_DoesNotHaveValue_Throws()
        {
            // Assemble
            int? me = null;

            // Act
            me.RequireHasValue("null");
        }

        [Test]
        public void RequireHasValue_HasValue_ReturnsParametersValue()
        {
            // Assemble
            int? expected = 5;

            // Act
            var actual = expected.RequireHasValue("null");

            // Assert
            Assert.AreEqual(expected, actual);
        }

        [Test]
        [ExpectedException(typeof(ArgumentNullException))]
        public void RequireNoNullOrtEmpty_Null_Throws()
        {
            // Assemble
            string me = null;

            // Act
            me.RequireNotNullOrEmpty("null");
        }

        [Test]
        [ExpectedException(typeof(ArgumentNullException))]
        public void RequireNoNullOrWhiteSpace_IsEmpty_Throws()
        {
            // Act
            string.Empty.RequireNotNullOrWhiteSpace("null");
        }

        [Test]
        [ExpectedException(typeof(ArgumentNullException))]
        public void RequireNoNullOrWhiteSpace_Null_Throws()
        {
            // Assemble
            string me = null;

            // Act
            me.RequireNotNullOrWhiteSpace("null");
        }

        [Test]
        public void RequireNotNull_IsNotNull_ReturnsParameter()
        {
            // Assemble
            object expected = new object();

            // Act
            var actual = expected.RequireNotNull("null");

            // Assert
            Assert.AreSame(expected, actual);
        }

        [Test]
        [ExpectedException(typeof(ArgumentNullException))]
        public void RequireNotNull_IsNull_Throws()
        {
            // Assemble
            object me = null;

            // Act
            me.RequireNotNull("null");
        }

        [Test]
        [ExpectedException(typeof(ArgumentNullException))]
        public void RequireNotNullOrEmpty_IsEmpty_Throws()
        {
            string.Empty.RequireNotNullOrEmpty("empty string");
        }

        [Test]
        public void RequireNotNullOrEmpty_NotEmpty_ReturnsParameter()
        {
            // Assemble
            string expected = "some value";

            // Act
            var actual = expected.RequireNotNullOrEmpty("value");

            // Assert
            Assert.AreEqual(expected, actual);
        }

        [Test]
        [ExpectedException(typeof(ArgumentNullException))]
        public void RequireNotNullOrWhiteSpace_IsWhiteSpace_Throws()
        {
            "    ".RequireNotNullOrWhiteSpace("whitespace string");
        }

        [Test]
        public void RequireNotNullOrWhiteSpace_NotEmpty_ReturnsParameter()
        {
            // Assemble
            string expected = "some value";

            // Act
            var actual = expected.RequireNotNullOrWhiteSpace("value");

            // Assert
            Assert.AreEqual(expected, actual);
        }
    }
}