text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <title>Bootstrap Starter Kit - Content Block 1-3</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="keywords" content="bskit, bootstrap starter kit, bootstrap builder" />
	<meta name="description" content="Business Startup & Prototyping HTML Framework" />

	<link rel="shortcut icon" href="ico/favicon.png">

    <link href="bootstrap/css/bootstrap.min.css" rel="stylesheet">
    <link href="css/font-awesome.min.css" rel="stylesheet">

	<link href="css/style-library-1.css" rel="stylesheet">

	<link href="css/content1-3.css" rel="stylesheet">

Every service under one roof

Digital Design

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed a lorem quis neque interdum consequat ut sed sem.

Web Development

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed a lorem quis neque interdum consequat ut sed sem.

Creative Direction

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed a lorem quis neque interdum consequat ut sed sem.

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace XenAdmin.Controls.SummaryPanel
{
    public interface ISummaryPanelView
    {
        string DrawTitle { set; }
        string DrawWarningMessage { set; }
        Bitmap DrawWarningIcon { set; }
        string DrawHelperUrl { set; }
        bool WarningTextVisiblity { set; }
        bool WarningIconVisiblity { set; }
        string DrawSummaryText { set; }
        string DrawSummaryLink { set; }
        LinkArea DrawSummaryLinkArea { set; }
        bool DrawHelperUrlVisible { set; }
        bool DrawInformationVisible { set; }
        string DrawInformationText { set; }
        Bitmap DrawInformationIcon { set; }
    }
}


text:
let passport = require('passport')
let nodeifyit = require('nodeifyit')
let LocalStrategy = require('passport-local').Strategy
let User = require('../models/user')
let util = require('util')
let FacebookStrategy = require('passport-facebook').Strategy
let TwitterStrategy = require('passport-twitter').Strategy
let GoogleStrategy = require('passport-google-oauth').OAuth2Strategy
require('songbird')

function useExternalPassportStrategy(OauthStrategy, config, field) {
  config.passReqToCallback = true
  passport.use(new OauthStrategy(config, nodeifyit(authCB, {spread: true})))

  async function authCB(req, token, tokenSecret, account) {
    console.log('req.body: ' + JSON.stringify(req.body))
    console.log('account ' + JSON.stringify(account))
    console.log('tokenSecret ' + tokenSecret)

    let socialid = account.id
    let idField = field + '.id'
    console.log('idField: ' + idField)
    let query = {}
    query[idField] = socialid
    console.log('Query: ' + JSON.stringify(query))
    //let user = await User.promise.findOne({'facebook.id': socialid})
    let user = await User.promise.findOne(query)
    let updateUser = false
    console.log('User from the DB: ' + user)
    console.log('User from the req: ' + req.user)

    // Authorization
    if (req.user) {
      let acccredentials = req.user[field]
      user = req.user
      console.log('User from the req - field: ' + acccredentials)
      if(!acccredentials.id){
        console.log('Updating acount profile info..')
        updateUser = true
      }
    } else { // Authentication - The user doesn't exist yet
    console.log('Else')
      if (!user) {
      // create the user
      user = new User()
      updateUser = true
      }
    }

    if(updateUser){
      if(field === 'facebook'){
        user = updateFacebookDetails(account, token, tokenSecret, user, field)
      } else if (field === 'twitter'){
        user = updateTwitterDetails(account, token, tokenSecret, user, field)
      }else if(field === 'google'){
        user = updateGoogleDetails(account, token, tokenSecret, user, field)
      }
      try{
        return await user.save()
      }catch(excep){
        console.log(util.inspect(excep))
        return [false, {message: excep.message}]
      }
      console.log('User after update: ' + user)
    } else {
      return user
    }
      // 1. Load user from store
      // 2. If req.user exists, we're authorizing (connecting an account)
      // 2a. Ensure it's not associated with another account
      // 2b. Link account
      // 3. If not, we're authenticating (logging in)
      // 3a. If user exists, we're logging in via the 3rd party account
      // 3b. Otherwise create a user associated with the 3rd party account
  }

  function updateTwitterDetails(account, token, tokenSecret, user, fieldname){
    user[fieldname].username = account.username
    user[fieldname].id = account.id
    user[fieldname].name = account.displayName
    user[fieldname].token = token
    user[fieldname].tokenSecret = tokenSecret
    return user
  }

  function updateFacebookDetails(account, token, tokenSecret, user, fieldname){
    console.log('Updating facebook profile info to the user: ' + user)
    user[fieldname].email = account.emails[0].value
    user[fieldname].id = account.id
    user[fieldname].name = account.displayName
    user[fieldname].token = token
    user[fieldname].tokenSecret = tokenSecret
    return user
  }

  function updateGoogleDetails(account, token, tokenSecret, user, fieldname){
    console.log('Updating google profile info to the user: ' + user)
    user[fieldname].email = account.emails[0].value
    user[fieldname].id = account.id
    user[fieldname].name = account.displayName
    user[fieldname].token = token
    user[fieldname].tokenSecret = tokenSecret
    return user
  }
}

function configure(config) {
  // Required for session support / persistent login sessions
  passport.serializeUser(nodeifyit(async (user) => user._id))

  passport.deserializeUser(nodeifyit(async (id) => {
    return await User.promise.findById(id)
  }))
console.log(JSON.stringify(config))
  // Facebook Auth Strategy
  useExternalPassportStrategy(FacebookStrategy, {
       clientID: config.facebookAuth.consumerKey,
       clientSecret: config.facebookAuth.consumerSecret,
       callbackURL: config.facebookAuth.callbackUrl
     }, 'facebook')

console.log('consumerKey: ' + config.twitterAuth.consumerKey)

  // Twitter Auth Strategy
  useExternalPassportStrategy(TwitterStrategy, {
       consumerKey: config.twitterAuth.consumerKey,
       consumerSecret: config.twitterAuth.consumerSecret,
       callbackURL: config.twitterAuth.callbackUrl
     }, 'twitter')

  //Google Auth Strategy
  useExternalPassportStrategy(GoogleStrategy, config.googleAuth, 'google')
  // useExternalPassportStrategy(LinkedInStrategy, {...}, 'linkedin')
  // useExternalPassportStrategy(LinkedInStrategy, {...}, 'google')
  // passport.use('local-login', new LocalStrategy({...}, (req, email, password, callback) => {...}))
  // passport.use('local-signup', new LocalStrategy({...}, (req, email, password, callback) => {...}))

  passport.use('local-signin', new LocalStrategy({
    // Use "email" field instead of "username"
    usernameField: 'email',
    failureFlash: true
  }, nodeifyit(async (email, password) => {
    let user
    //if(username.indexOf('@') != -1){
      email = email.toLowerCase()
      user = await User.promise.findOne({'local.email': email})

    if (!user) {
      return [false, {message: 'Invalid username'}]
    }
    let dbUserName = user.local.email
    /*if(username.indexOf('@') != -1){
      dbUserName = user.email
    }*/
    console.log(dbUserName)
    if (!user || email !== dbUserName) {
      return [false, {message: 'Invalid username'}]
    }

    if (!await user.validatePassword(password)) {
      return [false, {message: 'Invalid password'}]
    }
    return user
  }, {spread: true})))

passport.use('local-signup', new LocalStrategy({
    // Use "email" field instead of "username"
    usernameField: 'email',
    failureFlash: true,
    passReqToCallback: true
  }, nodeifyit(async (req, email, password) => {
      email = (email || '').toLowerCase()
      // Is the email taken?
      if (await User.promise.findOne({'local.email': email})) {
        return [false, {message: 'That email is already taken.'}]
      }

      // create the user
      let user = new User()
      user.local.email = email
      user.local.password = password
      try{
        return await user.save()
      }catch(excep){
        console.log(util.inspect(excep))
        return [false, {message: excep.message}]
      }
  }, {spread: true})))

  return passport
}

module.exports = {passport, configure}


text:
export const URL = {
  BASE: 'https://www.wandianshenme.com/api',
  PLAY: 'https://www.wandianshenme.com/api/play/',
  HOME: 'https://www.wandianshenme.com/api/home/',
  CATEGORY: 'https://www.wandianshenme.com/api/category/?limit=50',
  IMAGE_BASE: 'https://www.wandianshenme.com/static/media/'
};


text:
#include "../dl_loader.h"
#include "../get_gles_proc_address.h"
#include "../log.h"
#include "../target.h" // STDCALL

#include <string>
#include <sstream>

#include <windows.h>
#include <wingdi.h>

namespace {

std::string systemOpengl32Path() {
    char sysdir[MAX_PATH];
    GetSystemDirectoryA(sysdir, MAX_PATH-1);

    std::stringstream path;
    path << sysdir << "\\opengl32.dll";
    return path.str();
}

void* getGlesProcAddress(const char* name, bool bypassLocal) {
    using namespace core;
    typedef void* (*GPAPROC)(const char *name);

    static DlLoader opengl(bypassLocal ? systemOpengl32Path().c_str() : "opengl32.dll");
    if (GPAPROC gpa = reinterpret_cast<GPAPROC>(opengl.lookup("wglGetProcAddress"))) {
        if (void* proc = gpa(name)) {
            GAPID_DEBUG("GetGlesProcAddress(%s, %d) -> 0x%x (via opengl32 wglGetProcAddress)", name, bypassLocal, proc);
            return proc;
        }
    }
    if (void* proc = opengl.lookup(name)) {
        GAPID_DEBUG("GetGlesProcAddress(%s, %d) -> 0x%x (from opengl32 symbol)", name, bypassLocal, proc);
        return proc;
    }

    GAPID_DEBUG("GetGlesProcAddress(%s, %d) -> not found", name, bypassLocal);
    return nullptr;
}

}  // anonymous namespace

namespace core {

GetGlesProcAddressFunc* GetGlesProcAddress = getGlesProcAddress;
bool hasGLorGLES() {
    return DlLoader::can_load(systemOpengl32Path().c_str());
}

}  // namespace core


text:
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Inthros.AspNet.Views;
using Inthros.Core.Utilities;

namespace Inthros.AspNet.Builders
{
    public abstract class ActivityViewBuilder<T> : ActivityViewBuilder, IActivityViewBuilder<T>
    {
        private static readonly IReadOnlyCollection<Type> supportedTypes = new ReadOnlyCollection<Type>(new[] { typeof (T) });

        public abstract ActivityView Build(T activity);

        public sealed override ActivityView Build(object activity)
        {
            if (activity == null)
            {
                throw new ArgumentNullException("activity");
            }

            if (!this.Supports(activity.GetType()))
            {
                throw new ArgumentException("", "activity");
            }

            return this.Build((T) activity);
        }

        public sealed override IReadOnlyCollection<Type> SupportedTypes {
            get { return supportedTypes; }
        }
    }

    public abstract class ActivityViewBuilder : IActivityViewBuilder
    {
        protected bool IsCompatibleType(Type source, Type target)
        {
            return target.IsAssignableFrom(source) || source.IsConstructedGenericTypeOf(target);
        }

        public bool Supports(Type target)
        {
            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            return this.SupportedTypes.Any(t => IsCompatibleType(target, t));
        }

        public abstract ActivityView Build(object activity);

        public abstract IReadOnlyCollection<Type> SupportedTypes { get; }
    }
}


text:
package org.fhcrc.cpl.toolbox.proteomics.commandline.arguments;

import org.fhcrc.cpl.toolbox.TextProvider;
import org.fhcrc.cpl.toolbox.proteomics.MS2Modification;
import org.fhcrc.cpl.toolbox.ApplicationContext;
import org.fhcrc.cpl.toolbox.commandline.arguments.CommandLineArgumentDefinition;
import org.fhcrc.cpl.toolbox.commandline.arguments.ArgumentValidationException;
import org.fhcrc.cpl.toolbox.commandline.arguments.BaseArgumentDefinitionImpl;

import javax.swing.*;
import java.util.List;
import java.util.ArrayList;
import java.awt.*;

/**
 * Treats an argument as a comma-separated list of modifications.
 * Each mod should have the format:
 *
 * <residue><massdiff>[V]
 *
 * where V (case-insensitive) is an optional character indicating variable (default is static)
 *
 * for example:
 *
 * M16.5V
 *
 * means a variable modification on Methionine with deltamass 16.5
 */
public class ModificationListArgumentDefinition extends BaseArgumentDefinitionImpl
        implements CommandLineArgumentDefinition
{
    public ModificationListArgumentDefinition(String argumentName)
    {
        super(argumentName);
    }

    public ModificationListArgumentDefinition(String argumentName, String help)
    {
        super(argumentName, help);
    }

    public ModificationListArgumentDefinition(String argumentName, boolean required, String help)
    {
        super(argumentName, required, help);
    }

    public ModificationListArgumentDefinition(String argumentName, boolean required, String help,
                                              MS2Modification[] defaultValue)
    {
        super(argumentName, required, help, defaultValue);
    }

    /**
     * Try to match the argument against the set of allowed values, either with or without case-sensitivity
     * @param argumentValue
     * @return the argument as a String
     */
    public MS2Modification[] convertArgumentValue(String argumentValue)
            throws ArgumentValidationException
    {
        if (argumentValue.equalsIgnoreCase("none"))
            return new MS2Modification[0];
        List<MS2Modification> modList = new ArrayList<MS2Modification>();
        try
        {
            String[] modStrings = argumentValue.split(",");
            for (String modString : modStrings)
            {
                modList.add(createModificationFromString(modString));
            }
        }
        catch (Exception e)
        {
            throw new ArgumentValidationException(TextProvider.getText("COULDNT_PARSE_ARGUMENT_ARGUMENT", argumentValue));
        }
        return modList.toArray(new MS2Modification[modList.size()]);
    }

    public static MS2Modification safeCreateModificationFromString(String modString)
    {
        try
        {
            return createModificationFromString(modString);
        }
        catch (ArgumentValidationException e)
        {
            ApplicationContext.errorMessage("Failed to create modification for string: " + modString, e);
        }
        return null;
    }

    public static MS2Modification createModificationFromString(String modString)
            throws ArgumentValidationException
    {
        Character residue = modString.charAt(0);
        if (!Character.isLetter(residue))
            throw new ArgumentValidationException("Illegal residue character '" + residue + "'");
        boolean variable = false;
        if (modString.toLowerCase().endsWith("v"))
            variable = true;
        double massDiff = Double.parseDouble(modString.substring(1,
                variable? modString.length()-1 : modString.length()));
        MS2Modification result = new MS2Modification();
        result.setAminoAcid(("" + residue).toUpperCase());
        result.setVariable(variable);
        result.setMassDiff((float)massDiff);
        return result;
    }

    public String getValueDescriptor()
    {
        return "<residue><massdiff>[V][,...]";
    }

    /**
     * Need to override default handling, since we're working with an array, here.
     * @return
     */
    public String getDefaultValueAsString()
    {
        StringBuffer resultBuf = new StringBuffer();
        MS2Modification[] defaultValue = (MS2Modification[]) getDefaultValue();
        if (defaultValue == null || defaultValue.length < 1)
            return "";
        for (int i=0; i<defaultValue.length; i++)
        {
            MS2Modification mod = defaultValue[i];
            if (i>0)
                resultBuf.append(",");
            resultBuf.append(mod.getAminoAcid() + mod.getMassDiff());
            if (mod.getVariable())
                resultBuf.append("V");
        }
        return resultBuf.toString();
    }

    /**
     * Same as base method, but resize the text field
     * @param parent
     * @param parentDialog
     * @param defaultValue
     * @return
     */
    public JComponent addComponentsForGUI(Container parent, JDialog parentDialog, String defaultValue)
    {
        JTextField textField = (JTextField) super.addComponentsForGUI(parent, parentDialog, defaultValue);
        textField.setPreferredSize(new Dimension(70, 20));
        textField.setMinimumSize(new Dimension(70, 20));
        return textField;
    }
}


text:
"""Diagnostics support for bluetooth."""
from __future__ import annotations

import platform
from typing import Any

from bluetooth_adapters import get_dbus_managed_objects

from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant

from . import _get_manager

async def async_get_config_entry_diagnostics(
    hass: HomeAssistant, entry: ConfigEntry
) -> dict[str, Any]:
    """Return diagnostics for a config entry."""
    manager = _get_manager(hass)
    manager_diagnostics = await manager.async_diagnostics()
    adapters = await manager.async_get_bluetooth_adapters()
    diagnostics = {
        "manager": manager_diagnostics,
        "adapters": adapters,
    }
    if platform.system() == "Linux":
        diagnostics["dbus"] = await get_dbus_managed_objects()
    return diagnostics


text:
package org.caleydo.core.view.opengl.layout2;

import gleem.linalg.Vec2f;
import gleem.linalg.Vec4f;

import org.caleydo.core.view.opengl.layout2.geom.Rect;

/**
 * a layer above the content, i.e. for popups
 *
 * @author Samuel Gratzl
 *
 */
public interface IPopupLayer {
	/**
	 * closeable popup
	 */
	int FLAG_CLOSEABLE = 1 << 0;
	/**
	 * resizeable popup
	 */
	int FLAG_RESIZEABLE = 1 << 1;
	/**
	 * moveable popup
	 */
	int FLAG_MOVEABLE = 1 << 2;
	/**
	 * border around the popup
	 */
	int FLAG_BORDER = 1 << 3;
	/**
	 * collapse by double clicking the header
	 */
	int FLAG_COLLAPSABLE = 1 << 4;
	int FLAG_ALL = FLAG_CLOSEABLE | FLAG_RESIZEABLE | FLAG_MOVEABLE | FLAG_BORDER;

	/**
	 * see {@link #show(GLElement, Vec4f, int)} with all flags set
	 *
	 * @param popup
	 *            the popup to show
	 * @param bounds
	 *            its bounds
	 */
	void show(GLElement popup, Rect bounds);

	/**
	 * shows a popup with the given content and the given bounds
	 *
	 * @param popup
	 * @param bounds
	 *            (x,y: if negative count from the right side, if NaN centering), if null fullscreen
	 * @param flags
	 *            see {@link #FLAG_CLOSEABLE} and others
	 */
	void show(GLElement popup, Rect bounds, int flags);

	/**
	 * hides a popup again
	 *
	 * @param popup
	 */
	void hide(GLElement popup);

	/**
	 * @return
	 */
	Vec2f getSize();

	public interface IPopupElement {
		void hide();

		void shift(float dx, float dy);

		void setContentSize(float w, float h);
	}
}


text:
namespace SDK
	{

	namespace Utilities
		{

		UTILITIES_API void SleepSeconds(ulong i_seconds);
		UTILITIES_API void SleepMiliseconds(ulong i_miliseconds);

		} // Utilities

	} // SDK

#endif


text:
package example.com.powerinterview.activities;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.util.Base64;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.LinearLayout;

import com.loopj.android.http.AsyncHttpResponseHandler;
import com.loopj.android.http.JsonHttpResponseHandler;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Map;

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.Unbinder;
import cz.msebera.android.httpclient.Header;
import example.com.powerinterview.R;
import example.com.powerinterview.core.BaseInterviewController;
import example.com.powerinterview.core.BaseQuestionController;
import example.com.powerinterview.core.InterviewLogger;
import example.com.powerinterview.core.PowerInterviewApp;
import example.com.powerinterview.exceptions.ConvertException;
import example.com.powerinterview.exceptions.EncryptionException;
import example.com.powerinterview.exceptions.FactoryException;
import example.com.powerinterview.exceptions.InterviewElementNotFoundException;
import example.com.powerinterview.interfaces.IPIWidgetsFactory;
import example.com.powerinterview.interfaces.InterviewProvider;
import example.com.powerinterview.managers.AccountManager;
import example.com.powerinterview.managers.InterviewsTemplatesManager;
import example.com.powerinterview.model.Interview;
import example.com.powerinterview.model.Variable;
import example.com.powerinterview.network.InterviewClient;
import example.com.powerinterview.ui.CustomToast;
import example.com.powerinterview.utils.Converter;
import example.com.powerinterview.utils.Encrypt;
import example.com.powerinterview.utils.Validator;

public class InterviewActivity extends BaseWorkerActivity implements InterviewProvider {

    private AccountManager accountManager;
    private Unbinder unbinder;
    private InterviewsTemplatesManager interviewsTemplatesManager;
    private BaseInterviewController controller;
    private long interviewID;

    private InterviewClient interviewClient;

    private Interview interview;

    @BindView(R.id.interviewArea)
    LinearLayout interviewArea;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_interview);

        File file = (File) getIntent().getSerializableExtra("template");
        interviewID = getIntent().getLongExtra("id", -1);
        if(interviewID == -1)
            finish();

        interviewsTemplatesManager = ((PowerInterviewApp) getApplication()).getInterviewComponent().getInterviewManager();
        accountManager = ((PowerInterviewApp) getApplication()).getAuthComponent().accountManager();
        interviewClient = ((PowerInterviewApp) getApplication()).getInterviewComponent().getInterviewClient();

        unbinder = ButterKnife.bind(this);

        try {

            interview = interviewsTemplatesManager.loadInterviewByFile(file);
            IPIWidgetsFactory factory = ((PowerInterviewApp) getApplication()).getInterviewComponent().getWidgetsFactory();
            controller = new BaseInterviewController(this, new BaseQuestionController(factory));
            controller.initInterview(interview);

        } catch (Exception  e) {
            e.printStackTrace();
            handleException(e);
        }

        //clear log
        InterviewLogger.clearLog();

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbinder.unbind();
    }

    @Override
    public void displayViews(View[] views) {
        interviewArea.removeAllViews();
        for (View view: views) {
            interviewArea.addView(view);
        }
    }

    @Override
    public void endInterview() {

        final EditText respondentEmail = new EditText(this);
        respondentEmail.setHint(getString(R.string.respondent_email_string));
        respondentEmail.setMaxEms(20);
        AlertDialog alertDialog = new AlertDialog.Builder(this)
                .setMessage("Interview is over")
                .setPositiveButton("Send results", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        InterviewLogger.writeToInterviewLog("Interview is over");
                        InterviewLogger.writeToInterviewLog("Variables:");
                        Iterator it = interview.getVariables().entrySet().iterator();
                        while (it.hasNext()) {
                            Map.Entry<String, Variable> pair = (Map.Entry)it.next();
                            InterviewLogger.writeToInterviewLog(pair.getKey() + "---- " + pair.getValue().getValue());
                        }
                        String email = respondentEmail.getText().toString();
                        if(email.isEmpty() || !Validator.checkEmail(email)) {
                            InterviewActivity.this.showToast("Incorrect respondent's email", CustomToast.ToastType.TOAST_ALERT);
                            dialog.dismiss();
                            return;
                        }
                        sendInterview(email);

                    }
                })
                .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                    }
                }).create();
        alertDialog.setView(respondentEmail);
        alertDialog.show();
    }

    @Override
    public void handleException(Exception ex) {
        super.handleException(ex);
    }

    private void sendInterview(String respondentEmail) {

        String aes = null;
        try {
            aes = Encrypt.generateRandomAESKey();
        } catch (EncryptionException e) {
            e.printStackTrace();
            return;
        }

        try {
            showProgressDialog(getString(R.string.uploading));
            interviewClient.sendInterviewResults(accountManager.getToken(), interviewID, respondentEmail, new ByteArrayInputStream(InterviewLogger.getResults(aes)),null, aes,
                new JsonHttpResponseHandler() {

                    @Override
                    public void onSuccess(int statusCode, Header[] headers, JSONObject response) {

                        dismissProgressDialog();

                        try {
                            if(displayResult(response)) {

                                showSuccessDialog(response.getString("key"));
                            }
                        } catch (JSONException e) {
                            e.printStackTrace();
                        }

                    }

                    @Override
                    public void onFailure(int statusCode, Header[] headers, String responseString, Throwable throwable) {
                        dismissProgressDialog();
                        writeDebugLog("Interview loader", "exception from server, status code: " + statusCode + "message: " + responseString);
                    }
                });
        } catch (Exception e) {
            dismissProgressDialog();
            e.printStackTrace();
        }
    }

    private void showSuccessDialog(String key) {
        AlertDialog alertDialog = new AlertDialog.Builder(this)
                .setMessage(getString(R.string.inrerview_upload_success)  + key)
                .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                        finish();
                    }
                })
                .create();
        alertDialog.show();
    }

    @Override
    public Context getContext() {
        return this;
    }
}


text:
<robot xmlns:sensor="http://playerstage.sourceforge.net/gazebo/xmlschema/#sensor"
       xmlns:controller="http://playerstage.sourceforge.net/gazebo/xmlschema/#controller"
       xmlns:interface="http://playerstage.sourceforge.net/gazebo/xmlschema/#interface">
<!--
  <gazebo>
    <plugin name="lwr_controller" filename="liblwr_controller.so">
      <alwaysOn>true</alwaysOn>
      <robotPrefix>lwr</robotPrefix>
      <remotePort>49938</remotePort>
      <lwr_arm_0_joint>0.0</lwr_arm_0_joint>
      <lwr_arm_1_joint>0.7</lwr_arm_1_joint>
      <lwr_arm_2_joint>0.0</lwr_arm_2_joint>
      <lwr_arm_3_joint>-0.7</lwr_arm_3_joint>
      <lwr_arm_4_joint>0.7</lwr_arm_4_joint>
      <lwr_arm_5_joint>0.7</lwr_arm_5_joint>
      <lwr_arm_6_joint>0.7</lwr_arm_6_joint>
    </plugin>
  </gazebo>
-->
  <gazebo>
    <plugin name="rtt_gazebo" filename="librtt_gazebo_plugin.so">
      <opsScript>
        import("rtt_ros");
        ros.import("rtt_roscomm");
        ros.import("rtt_rosparam");
        ros.import("rtt_sensor_msgs");
        ros.import("lwr_simulation");
        ros.import("oro_joint_state_publisher");

        loadComponent("FRI","LWRController");
        loadComponent("joints","JointStatePublisher");

        loadService("FRI","rosparam");
        loadService("joints","rosparam");

        setActivity("FRI", 0.0, 5, ORO_SCHED_RT);
        setActivity("joints", 0.02, 5, ORO_SCHED_RT);

        connect("FRI.JointPosition","joints.msrJntPos", ConnPolicy());
        stream("joints.joints_state", rostopic.connection("/joints_state"));

        joints.rosparam.refreshProperties();
        joints.configure();
        joints.start();
      </opsScript>

      <component>FRI</component>
    </plugin>
  </gazebo>

</robot>


text:
#ifndef __handle_manager_hpp__
#define __handle_manager_hpp__

#include <ioa/automaton_manager_interface.hpp>
#include <ioa/scheduler.hpp>

namespace ioa {

  template <class T>
  class handle_manager :
    public automaton_handle_interface<T>
  {
  private:
    automaton_handle<T> m_handle;

  public:
    typedef T instance;

    handle_manager () { }

    handle_manager (const automaton_handle<T>& handle) :
      m_handle (handle)
    { }

    automaton_handle<T> get_handle () const {
      return m_handle;
    }

  };

}

#endif


text:
//-----------------------------------------------------------------------
// <copyright file="GeneralMidiPercussion.cs" company="Stephen Toub">
//     Copyright (c) Stephen Toub. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------

namespace MidiSharp
{
    /// General MIDI Percussion Patch Map.
    public enum GeneralMidiPercussion : byte
    {
        /// Bass Drum
        BassDrum = 35,
        /// Bass Drum 1
        BassDrum1 = 36,
        /// Side Stick
        SideStick = 37,
        /// Acoustic Snare
        AcousticSnare = 38,
        /// Hand Clap
        HandClap = 39,
        /// Electric Snare
        ElectricSnare = 40,
        /// Low Floor Tom
        LowFloorTom = 41,
        /// Closed Hi Hat
        ClosedHiHat = 42,
        /// High Floor Tom
        HighFloorTom = 43,
        /// Pedal Hi Hat
        PedalHiHat = 44,
        /// Low Tom
        LowTom = 45,
        /// Open Hi Hat
        OpenHiHat = 46,
        /// Low Mid Tom
        LowMidTom = 47,
        /// Hi Mid Tom
        HiMidTom = 48,
        /// Crash Cymbal 1
        CrashCymbal1 = 49,
        /// High Tom
        HighTom = 50,
        /// Ride Cymbal
        RideCymbal = 51,
        /// Chinese Cymbal
        ChineseCymbal = 52,
        /// Ride Bell
        RideBell = 53,
        /// Tambourine
        Tambourine = 54,
        /// Splash Cymbal
        SplashCymbal = 55,
        /// Cowbell
        Cowbell = 56,
        /// Crash Cymbal 2
        CrashCymbal2 = 57,
        /// Vibraslap
        Vibraslap = 58,
        /// Ride Cymbal 2
        RideCymbal2 = 59,
        /// Hi Bongo
        HiBongo = 60,
        /// Low Bongo
        LowBongo = 61,
        /// Mute Hi Conga
        MuteHiConga = 62,
        /// Open Hi Conga
        OpenHiConga = 63,
        /// Low Conga
        LowConga = 64,
        /// High Timbale
        HighTimbale = 65,
        /// Low Timbale
        LowTimbale = 66,
        /// High Agogo
        HighAgogo = 67,
        /// Low Agogo
        LowAgogo = 68,
        /// Cabasa
        Cabasa = 69,
        /// Maracas
        Maracas = 70,
        /// Short Whistle
        ShortWhistle = 71,
        /// Long Whistle
        LongWhistle = 72,
        /// Short Guiro
        ShortGuiro = 73,
        /// Long Guiro
        LongGuiro = 74,
        /// Claves
        Claves = 75,
        /// Hi Wood Block
        HiWoodBlock = 76,
        /// Low Wood Block
        LowWoodBlock = 77,
        /// Mute Cuica
        MuteCuica = 78,
        /// Open Cuica
        OpenCuica = 79,
        /// Mute Triangle
        MuteTriangle = 80,
        /// Open Triangle
        OpenTriangle = 81
    }
}


text:
package gov.hhs.fha.nhinc.messaging.service.port;

/**
 * @author akong
 *
 */
public interface ServicePortDescriptor<T> {

    public String getNamespaceUri();

    public String getServiceLocalPart();

    public String getPortLocalPart();

    public String getWSDLFileName();

    public String getWSAddressingAction();

    public Class<T> getPortClass();
}


text:
copyright:
  years: 2015, 2017

lastupdated: "2017-03-06"

---

{:shortdesc: .shortdesc}
{:new_window: target="_blank"}
{:codeblock: .codeblock}
{:screen: .screen}

# Hilfe und Support für die Überwachung anfordern
{: #gettinghelp}

Wenn Sie bei der Verwendung der Überwachungsfunktionen in {{site.data.keyword.Bluemix}} Probleme oder Fragen haben, können Sie {{site.data.keyword.Bluemix_notm}} überprüfen oder Hilfe erhalten, indem Sie nach Informationen suchen oder Fragen in einem Forum stellen. Sie können außerdem ein Support-Ticket öffnen.
{:shortdesc}

* Sie können prüfen, ob {{site.data.keyword.Bluemix_notm}} verfügbar ist, indem Sie die [Bluemix-Statusseite](https://developer.ibm.com/bluemix/support/#status){:new_window} aufrufen.

* Sie können die Foren prüfen, um festzustellen, ob andere Benutzer dasselbe Problem hatten. Wenn Sie in den Foren eine Frage stellen, versehen Sie Ihre Frage mit einem Tag, um die {{site.data.keyword.Bluemix_notm}}-Entwicklungsteams auf die Frage aufmerksam zu machen.
<!--Insert the appropriate Stack Overflow tag for your service for <service_keyword> in URL and text below:  -->
  * Wenn Sie technische Fragen zur Entwicklung oder Bereitstellung einer App mit 'Servicekurzname' haben, reichen Sie Ihre Frage bei [Stack Overflow](http://stackoverflow.com/search?q=monitoring+ibm-bluemix){:new_window} ein und versehen sie mit den Tags "ibm-bluemix" und "monitoring".
<!--Insert the appropriate dW Answers tag for your service for <service_keyword> in URL below:  -->
  * Bei Fragen zu dem Service und zum Anfordern von Anweisungen für den Einstieg verwenden Sie das Forum [IBM developerWorks dW Answers](https://developer.ibm.com/answers/topics/monitoring/?smartspace=bluemix){:new_window}. Geben Sie die Tags "monitoring" und "bluemix" an.

Weitere Details zur Nutzung der Foren finden Sie unter [Hilfe aufrufen](https://www.{DomainName}/docs/support/index.html#getting-help).

* Wenn sich das Problem auf diese Weise nicht lösen lässt, können Sie ein IBM Support-Ticket öffnen. Informationen zum Öffnen eines IBM Support-Tickets oder zu den Supportebenen und den Prioritätsstufen von Tickets finden Sie unter [Support kontaktieren](https://www.{DomainName}/docs/support/index.html#contacting-support).


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

import static com.google.common.truth.Truth.assertThat;

import com.google.devtools.build.lib.actions.Action;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.actions.util.ActionsTestUtil;
import com.google.devtools.build.lib.analysis.ConfiguredTarget;
import com.google.devtools.build.lib.analysis.RunfilesProvider;
import com.google.devtools.build.lib.analysis.actions.FileWriteAction;
import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**
 * Abstract base class for tests of {@link BazelAndroidLocalTest}. These tests are for the java
 * related portions of the rule. Be sure to use writeFile() and overwriteFile() (instead of
 * scratch.writeFile() and scratch.overwriteFile()).
 */
@RunWith(JUnit4.class)
public abstract class AbstractAndroidLocalTestTestBase extends BuildViewTestCase {

  @Before
  public void setUp() throws Exception {
    writeFile("java/bar/BUILD", "");
    writeFile("java/bar/foo.bzl", "extra_deps = []");
  }

  @Test
  public void testSimpleAndroidRobolectricConfiguredTarget() throws Exception {
    writeFile(
        "java/test/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "android_local_test(name = 'dummyTest',",
        "    srcs = ['test.java'],",
        "    deps = extra_deps)");
    ConfiguredTarget target = getConfiguredTarget("//java/test:dummyTest");
    assertThat(target).isNotNull();
    checkMainClass(target, "dummyTest", false);
  }

  @Test
  public void testDataDependency() throws Exception {
    writeFile(
        "java/test/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "android_local_test(name = 'dummyTest',",
        "    srcs = ['test.java'],",
        "    deps = extra_deps,",
        "    data = ['data.dat'])");

    writeFile("java/test/data.dat",
        "this is a dummy data file");

    ConfiguredTarget target = getConfiguredTarget("//java/test:dummyTest");
    Artifact data = getFileConfiguredTarget("//java/test:data.dat")
        .getArtifact();
    RunfilesProvider runfiles = target.getProvider(RunfilesProvider.class);

    assertThat(runfiles.getDataRunfiles().getAllArtifacts().toSet()).contains(data);
    assertThat(runfiles.getDefaultRunfiles().getAllArtifacts().toSet()).contains(data);
    assertThat(target).isNotNull();
  }

  @Test
  public void testNeverlinkRuntimeDepsExclusionReportsError() throws Exception {
    useConfiguration("--noexperimental_allow_runtime_deps_on_neverlink");
    checkError("java/test", "test",
        "neverlink dep //java/test:neverlink_lib not allowed in runtime deps",
        String.format("%s(name = 'test',", getRuleName()),
        "    srcs = ['test.java'],",
        "    runtime_deps = [':neverlink_lib'])",
        "android_library(name = 'neverlink_lib',",
        "                srcs = ['dummyNeverlink.java'],",
        "                neverlink = 1,)");
  }

  @Test
  public void testFeatureFlagsAttributeSetsSelectInDependency() throws Exception {
    useConfiguration(
        "--experimental_dynamic_configs=on",
        "--enforce_transitive_configs_for_config_feature_flag");
    writeFile(
        "java/com/foo/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "config_feature_flag(",
        "  name = 'flag1',",
        "  allowed_values = ['on', 'off'],",
        "  default_value = 'off',",
        ")",
        "config_setting(",
        "  name = 'flag1@on',",
        "  flag_values = {':flag1': 'on'},",
        "  transitive_configs = [':flag1'],",
        ")",
        "config_feature_flag(",
        "  name = 'flag2',",
        "  allowed_values = ['on', 'off'],",
        "  default_value = 'off',",
        ")",
        "config_setting(",
        "  name = 'flag2@on',",
        "  flag_values = {':flag2': 'on'},",
        "  transitive_configs = [':flag2'],",
        ")",
        "android_library(",
        "  name = 'lib',",
        "  srcs = select({",
        "    ':flag1@on': ['Flag1On.java'],",
        "    '//conditions:default': ['Flag1Off.java'],",
        "  }) + select({",
        "    ':flag2@on': ['Flag2On.java'],",
        "    '//conditions:default': ['Flag2Off.java'],",
        "  }),",
        "  transitive_configs = [':flag1', ':flag2'],",
        ")",
        "android_local_test(",
        "  name = 'foo',",
        "  srcs = ['Test.java'],",
        "  deps = [':lib'] + extra_deps,",
        "  feature_flags = {",
        "    'flag1': 'on',",
        "  },",
        "  transitive_configs = [':flag1', ':flag2'],",
        ")");
    ConfiguredTarget binary = getConfiguredTarget("//java/com/foo");
    List<String> inputs =
        actionsTestUtil()
            .prettyArtifactNames(actionsTestUtil().artifactClosureOf(getFilesToBuild(binary)));

    assertThat(inputs).containsAllOf("java/com/foo/Flag1On.java", "java/com/foo/Flag2Off.java");
    assertThat(inputs).containsNoneOf("java/com/foo/Flag1Off.java", "java/com/foo/Flag2On.java");
  }

  @Test
  public void testFeatureFlagsAttributeSetsSelectInTest() throws Exception {
    useConfiguration(
        "--experimental_dynamic_configs=on",
        "--enforce_transitive_configs_for_config_feature_flag");
    writeFile(
        "java/com/foo/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "config_feature_flag(",
        "  name = 'flag1',",
        "  allowed_values = ['on', 'off'],",
        "  default_value = 'off',",
        ")",
        "config_setting(",
        "  name = 'flag1@on',",
        "  flag_values = {':flag1': 'on'},",
        "  transitive_configs = [':flag1'],",
        ")",
        "config_feature_flag(",
        "  name = 'flag2',",
        "  allowed_values = ['on', 'off'],",
        "  default_value = 'off',",
        ")",
        "config_setting(",
        "  name = 'flag2@on',",
        "  flag_values = {':flag2': 'on'},",
        "  transitive_configs = [':flag2'],",
        ")",
        "android_local_test(",
        "  name = 'foo',",
        "  deps = extra_deps,",
        "  srcs = ['Test.java'] + select({",
        "    ':flag1@on': ['Flag1On.java'],",
        "    '//conditions:default': ['Flag1Off.java'],",
        "  }) + select({",
        "    ':flag2@on': ['Flag2On.java'],",
        "    '//conditions:default': ['Flag2Off.java'],",
        "  }),",
        "  feature_flags = {",
        "    'flag1': 'on',",
        "  },",
        "  transitive_configs = [':flag1', ':flag2'],",
        ")");
    ConfiguredTarget binary = getConfiguredTarget("//java/com/foo");
    List<String> inputs =
        actionsTestUtil()
            .prettyArtifactNames(actionsTestUtil().artifactClosureOf(getFilesToBuild(binary)));

    assertThat(inputs).containsAllOf("java/com/foo/Flag1On.java", "java/com/foo/Flag2Off.java");
    assertThat(inputs).containsNoneOf("java/com/foo/Flag1Off.java", "java/com/foo/Flag2On.java");
  }

  @Test
  public void testFeatureFlagsAttributeFailsAnalysisIfFlagValueIsInvalid() throws Exception {
    reporter.removeHandler(failFastHandler);
    useConfiguration(
        "--experimental_dynamic_configs=on",
        "--enforce_transitive_configs_for_config_feature_flag");
    writeFile(
        "java/com/foo/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "config_feature_flag(",
        "  name = 'flag1',",
        "  allowed_values = ['on', 'off'],",
        "  default_value = 'off',",
        ")",
        "config_setting(",
        "  name = 'flag1@on',",
        "  flag_values = {':flag1': 'on'},",
        "  transitive_configs = [':flag1'],",
        ")",
        "android_library(",
        "  name = 'lib',",
        "  srcs = select({",
        "    ':flag1@on': ['Flag1On.java'],",
        "    '//conditions:default': ['Flag1Off.java'],",
        "  }),",
        "  transitive_configs = [':flag1'],",
        ")",
        "android_local_test(",
        "  name = 'foo',",
        "  srcs = ['Test.java'],",
        "  deps = [':lib',] + extra_deps,",
        "  feature_flags = {",
        "    'flag1': 'invalid',",
        "  },",
        "  transitive_configs = [':flag1'],",
        ")");
    assertThat(getConfiguredTarget("//java/com/foo")).isNull();
    assertContainsEvent(
        "in config_feature_flag rule //java/com/foo:flag1: "
            + "value must be one of [\"off\", \"on\"], but was \"invalid\"");
  }

  @Test
  public void testFeatureFlagsAttributeFailsAnalysisIfFlagValueIsInvalidEvenIfNotUsed()
      throws Exception {
    reporter.removeHandler(failFastHandler);
    useConfiguration(
        "--experimental_dynamic_configs=on",
        "--enforce_transitive_configs_for_config_feature_flag");
    writeFile(
        "java/com/foo/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "config_feature_flag(",
        "  name = 'flag1',",
        "  allowed_values = ['on', 'off'],",
        "  default_value = 'off',",
        ")",
        "config_setting(",
        "  name = 'flag1@on',",
        "  flag_values = {':flag1': 'on'},",
        ")",
        "android_local_test(",
        "  name = 'foo',",
        "  srcs = ['Test.java'],",
        "  deps = extra_deps,",
        "  feature_flags = {",
        "    'flag1': 'invalid',",
        "  }",
        ")");
    assertThat(getConfiguredTarget("//java/com/foo")).isNull();
    assertContainsEvent(
        "in config_feature_flag rule //java/com/foo:flag1: "
            + "value must be one of [\"off\", \"on\"], but was \"invalid\"");
  }

  @Test
  public void testFeatureFlagsAttributeSetsFeatureFlagProviderValues() throws Exception {
    useConfiguration(
        "--experimental_dynamic_configs=on",
        "--enforce_transitive_configs_for_config_feature_flag");
    writeFile(
        "java/com/foo/reader.bzl",
        "def _impl(ctx):",
        "  ctx.actions.write(",
        "      ctx.outputs.java,",
        "      '\\n'.join([",
        "          str(target.label) + ': ' + target[config_common.FeatureFlagInfo].value",
        "          for target in ctx.attr.flags]))",
        "  return struct(files=depset([ctx.outputs.java]))",
        "flag_reader = rule(",
        "  implementation=_impl,",
        "  attrs={'flags': attr.label_list(providers=[config_common.FeatureFlagInfo])},",
        "  outputs={'java': '%{name}.java'},",
        ")");
    writeFile(
        "java/com/foo/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "load('//java/com/foo:reader.bzl', 'flag_reader')",
        "config_feature_flag(",
        "  name = 'flag1',",
        "  allowed_values = ['on', 'off'],",
        "  default_value = 'off',",
        ")",
        "config_feature_flag(",
        "  name = 'flag2',",
        "  allowed_values = ['on', 'off'],",
        "  default_value = 'off',",
        ")",
        "flag_reader(",
        "  name = 'FooFlags',",
        "  flags = [':flag1', ':flag2'],",
        "  transitive_configs = [':flag1', ':flag2'],",
        ")",
        "android_local_test(",
        "  name = 'foo',",
        "  srcs = ['Test.java', ':FooFlags.java'],",
        "  deps = extra_deps,",
        "  feature_flags = {",
        "    'flag1': 'on',",
        "  },",
        "  transitive_configs = [':flag1', ':flag2'],",
        ")");
    Artifact flagList =
        actionsTestUtil().getFirstArtifactEndingWith(
            actionsTestUtil()
                .artifactClosureOf(getFilesToBuild(getConfiguredTarget("//java/com/foo"))),
            "/FooFlags.java");
    FileWriteAction action = (FileWriteAction) getGeneratingAction(flagList);
    assertThat(action.getFileContents())
        .isEqualTo("//java/com/foo:flag1: on\n//java/com/foo:flag2: off");
  }

  @Test
  public void testFeatureFlagsAttributeFailsAnalysisIfFlagIsAliased()
      throws Exception {
    reporter.removeHandler(failFastHandler);
    useConfiguration(
        "--experimental_dynamic_configs=on",
        "--enforce_transitive_configs_for_config_feature_flag");
    writeFile(
        "java/com/foo/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "config_feature_flag(",
        "  name = 'flag1',",
        "  allowed_values = ['on', 'off'],",
        "  default_value = 'off',",
        ")",
        "alias(",
        "  name = 'alias',",
        "  actual = 'flag1',",
        "  transitive_configs = [':flag1'],",
        ")",
        "android_local_test(",
        "  name = 'foo',",
        "  srcs = ['Test.java'],",
        "  deps = extra_deps,",
        "  feature_flags = {",
        "    'alias': 'on',",
        "  },",
        "  transitive_configs = [':flag1'],",
        ")");
    assertThat(getConfiguredTarget("//java/com/foo")).isNull();
    assertContainsEvent(String.format(
        "in feature_flags attribute of %s rule //java/com/foo:foo: "
            + "Feature flags must be named directly, not through aliases; "
            + "use '//java/com/foo:flag1', not '//java/com/foo:alias'", getRuleName()));
  }

  @Test
  public void testFeatureFlagPolicyMustBeVisibleToRuleToUseFeatureFlags() throws Exception {
    reporter.removeHandler(failFastHandler); // expecting an error
    useConfiguration("--enforce_transitive_configs_for_config_feature_flag");
    overwriteFile(
        "tools/whitelists/config_feature_flag/BUILD",
        "package_group(",
        "    name = 'config_feature_flag',",
        "    packages = ['//flag'])");
    writeFile(
        "flag/BUILD",
        "config_feature_flag(",
        "    name = 'flag',",
        "    allowed_values = ['right', 'wrong'],",
        "    default_value = 'right',",
        "    visibility = ['//java/com/google/android/foo:__pkg__'],",
        ")");
    writeFile(
        "java/com/google/android/foo/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "android_local_test(",
        "  name = 'foo',",
        "  srcs = ['Test.java', ':FooFlags.java'],",
        "  deps = extra_deps,",
        "  feature_flags = {",
        "    '//flag:flag': 'right',",
        "  },",
        "  transitive_configs = ['//flag:flag'],",
        ")");
    assertThat(getConfiguredTarget("//java/com/google/android/foo:foo")).isNull();
    assertContainsEvent(
        String.format("in feature_flags attribute of %s rule "
            + "//java/com/google/android/foo:foo: the feature_flags attribute is not available in "
            + "package 'java/com/google/android/foo'", getRuleName()));
  }

  @Test
  public void testFeatureFlagPolicyDoesNotBlockRuleIfInPolicy() throws Exception {
    useConfiguration("--enforce_transitive_configs_for_config_feature_flag");
    overwriteFile(
        "tools/whitelists/config_feature_flag/BUILD",
        "package_group(",
        "    name = 'config_feature_flag',",
        "    packages = ['//flag', '//java/com/google/android/foo'])");
    writeFile(
        "flag/BUILD",
        "config_feature_flag(",
        "    name = 'flag',",
        "    allowed_values = ['right', 'wrong'],",
        "    default_value = 'right',",
        "    visibility = ['//java/com/google/android/foo:__pkg__'],",
        ")");
    writeFile(
        "java/com/google/android/foo/BUILD",
        "load('//java/bar:foo.bzl', 'extra_deps')",
        "android_local_test(",
        "  name = 'foo',",
        "  srcs = ['Test.java', ':FooFlags.java'],",
        "  deps = extra_deps,",
        "  feature_flags = {",
        "    '//flag:flag': 'right',",
        "  },",
        "  transitive_configs = ['//flag:flag'],",
        ")");
    assertThat(getConfiguredTarget("//java/com/google/android/foo:foo")).isNotNull();
    assertNoEvents();
  }

  @Test
  public void testFeatureFlagPolicyIsNotUsedIfFlagValuesNotUsed() throws Exception {
    overwriteFile(
        "tools/whitelists/config_feature_flag/BUILD",
        "package_group(",
        "    name = 'config_feature_flag',",
        "    packages = ['*super* busted package group'])");
    writeFile(
        "java/com/google/android/foo/BUILD",
        "android_local_test(",
        "  name = 'foo',",
        "  srcs = ['Test.java', ':FooFlags.java'],",
        ")");
    assertThat(getConfiguredTarget("//java/com/google/android/foo:foo")).isNotNull();
    // the package_group is busted, so we would have failed to get this far if we depended on it
    assertNoEvents();
    // sanity check time: does this test actually test what we're testing for?
    reporter.removeHandler(failFastHandler);
    assertThat(getConfiguredTarget("//tools/whitelists/config_feature_flag:config_feature_flag"))
        .isNull();
    assertContainsEvent("*super* busted package group");
  }

  @Test
  public void testDeployJar() throws Exception {
    writeFile(
        "java/com/google/android/foo/BUILD",
        "android_local_test(name = 'test',",
        "                srcs =['test.java'],",
        "                )",
        "android_library(name = 'lib',",
        "                data = [':test_deploy.jar'],",
        "                srcs =['lib.java'],",
        "                )");

    Action deployJarAction =
        getGeneratingAction(
            getFileConfiguredTarget("//java/com/google/android/foo:test_deploy.jar").getArtifact());
    List<String> inputs = ActionsTestUtil.baseArtifactNames(deployJarAction.getInputs());

    assertThat(inputs)
        .containsAllOf(
            "test_resources.jar",
            "test.jar",
            "SingleJar_deploy.jar");
  }

  public abstract void checkMainClass(
      ConfiguredTarget target, String targetName, boolean coverageEnabled) throws Exception;

  protected abstract String getRuleName();

  protected abstract void writeFile(String path, String... lines) throws Exception;

  protected abstract void overwriteFile(String path, String... lines) throws Exception;
}


text:
x-project
=========

android chat


text:
// MIT License. Copyright (c) 2016 Maxim Kuzmin. Contacts: https://github.com/maxim-kuzmin

// Author: Maxim Kuzmin

using Makc2017.Data.Entity.Objects;
using Makc2017.Modules.DummyManyToMany.Filters;
using System.Linq;

namespace Makc2017.Modules.DummyManyToMany.Data.Entity.Extensions.OfQueryItem
{
    /// <summary>
    /// Модули. Модуль "DummyManyToMany". Данные. Entity Framework. Расширения. Расширение запроса элемента.
    /// </summary>
    public static class ModuleDummyManyToManyDataEntityExtensionOfQueryItem
    {
        #region Public methods

        /// <summary>
        /// Применить фильтрацию.
        /// </summary>
        /// <param name="query">Запрос.</param>
        /// <param name="filter">Фильтр.</param>
        /// <returns>Запрос с учётом фильтрации.</returns>
        public static IQueryable<DataEntityObjectDummyManyToMany> ApplyFiltering(
            this IQueryable<DataEntityObjectDummyManyToMany> query,
            ModuleDummyManyToManyFilterItem filter
            )
        {
            query = query.Where(x => x.Id == filter.Id);

            return query;
        }

        #endregion Public methods
    }
}


text:
namespace Netfox.Detective.Interfaces
{
    internal interface IInvestigationFactoryInternal : IInvestigationFactory
    {
    }
}


text:
class CreateSpreeSuburbs < ActiveRecord::Migration
  def change
    create_table :spree_suburbs do |t|
      t.string :name
      t.belongs_to :city, index: true

      t.timestamps
    end
  end
end


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

#ifndef CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_TEST_HELPER_H_
#define CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_TEST_HELPER_H_

#include <stdint.h>

#include <map>
#include <string>
#include <vector>

#include "base/callback.h"
#include "base/containers/hash_tables.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/optional.h"
#include "base/time/time.h"
#include "content/common/service_worker/embedded_worker.mojom.h"
#include "content/common/service_worker/fetch_event_dispatcher.mojom.h"
#include "content/common/service_worker/service_worker_status_code.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_test_sink.h"
#include "mojo/public/cpp/bindings/binding.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "services/service_manager/public/cpp/interface_registry.h"
#include "services/service_manager/public/interfaces/interface_provider.mojom.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"

class GURL;
struct ServiceWorkerMsg_ExtendableMessageEvent_Params;

namespace service_manager {
class InterfaceProvider;
class InterfaceRegistry;
}

namespace content {

class EmbeddedWorkerRegistry;
class EmbeddedWorkerTestHelper;
class MessagePortMessageFilter;
class MockRenderProcessHost;
class ServiceWorkerContextCore;
class ServiceWorkerContextWrapper;
class TestBrowserContext;
struct EmbeddedWorkerStartParams;
struct PushEventPayload;
struct ServiceWorkerFetchRequest;

// In-Process EmbeddedWorker test helper.
//
// Usage: create an instance of this class to test browser-side embedded worker
// code without creating a child process.  This class will create a
// ServiceWorkerContextWrapper and ServiceWorkerContextCore for you.
//
// By default this class just notifies back WorkerStarted and WorkerStopped
// for StartWorker and StopWorker requests. The default implementation
// also returns success for event messages (e.g. InstallEvent, FetchEvent).
//
// Alternatively consumers can subclass this helper and override On*()
// methods to add their own logic/verification code.
//
// See embedded_worker_instance_unittest.cc for example usages.
//
class EmbeddedWorkerTestHelper : public IPC::Sender,
                                 public IPC::Listener {
 public:
  using FetchCallback =
      base::Callback<void(ServiceWorkerStatusCode,
                          base::Time /* dispatch_event_time */)>;

  class MockEmbeddedWorkerInstanceClient
      : public mojom::EmbeddedWorkerInstanceClient {
   public:
    explicit MockEmbeddedWorkerInstanceClient(
        base::WeakPtr<EmbeddedWorkerTestHelper> helper);
    ~MockEmbeddedWorkerInstanceClient() override;

    static void Bind(const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
                     mojom::EmbeddedWorkerInstanceClientRequest request);

   protected:
    // Implementation of mojo interfaces.
    void StartWorker(
        const EmbeddedWorkerStartParams& params,
        service_manager::mojom::InterfaceProviderPtr browser_interfaces,
        service_manager::mojom::InterfaceProviderRequest renderer_request)
        override;
    void StopWorker(const StopWorkerCallback& callback) override;

    base::WeakPtr<EmbeddedWorkerTestHelper> helper_;
    mojo::Binding<mojom::EmbeddedWorkerInstanceClient> binding_;

    base::Optional<int> embedded_worker_id_;

   private:
    DISALLOW_COPY_AND_ASSIGN(MockEmbeddedWorkerInstanceClient);
  };

  // If |user_data_directory| is empty, the context makes storage stuff in
  // memory.
  explicit EmbeddedWorkerTestHelper(const base::FilePath& user_data_directory);
  ~EmbeddedWorkerTestHelper() override;

  // Call this to simulate add/associate a process to a pattern.
  // This also registers this sender for the process.
  void SimulateAddProcessToPattern(const GURL& pattern, int process_id);

  // IPC::Sender implementation.
  bool Send(IPC::Message* message) override;

  // IPC::Listener implementation.
  bool OnMessageReceived(const IPC::Message& msg) override;

  // Register a mojo endpoint object derived from
  // MockEmbeddedWorkerInstanceClient.
  void RegisterMockInstanceClient(
      std::unique_ptr<MockEmbeddedWorkerInstanceClient> client);

  template <typename MockType, typename... Args>
  MockType* CreateAndRegisterMockInstanceClient(Args&&... args);

  // IPC sink for EmbeddedWorker messages.
  IPC::TestSink* ipc_sink() { return &sink_; }
  // Inner IPC sink for script context messages sent via EmbeddedWorker.
  IPC::TestSink* inner_ipc_sink() { return &inner_sink_; }

  std::vector<std::unique_ptr<MockEmbeddedWorkerInstanceClient>>*
  mock_instance_clients() {
    return &mock_instance_clients_;
  }

  ServiceWorkerContextCore* context();
  ServiceWorkerContextWrapper* context_wrapper() { return wrapper_.get(); }
  void ShutdownContext();

  int GetNextThreadId() { return next_thread_id_++; }

  int mock_render_process_id() const { return mock_render_process_id_; }
  MockRenderProcessHost* mock_render_process_host() {
    return render_process_host_.get();
  }

  std::map<int, int64_t> embedded_worker_id_service_worker_version_id_map() {
    return embedded_worker_id_service_worker_version_id_map_;
  }

  // Only used for tests that force creating a new render process.
  int new_render_process_id() const { return new_mock_render_process_id_; }

  TestBrowserContext* browser_context() { return browser_context_.get(); }

  base::WeakPtr<EmbeddedWorkerTestHelper> AsWeakPtr() {
    return weak_factory_.GetWeakPtr();
  }

 protected:
  // Called when StartWorker, StopWorker and SendMessageToWorker message
  // is sent to the embedded worker. Override if necessary. By default
  // they verify given parameters and:
  // - OnStartWorker calls SimulateWorkerStarted
  // - OnStopWorker calls SimulateWorkerStoped
  // - OnSendMessageToWorker calls the message's respective On*Event handler
  virtual void OnStartWorker(int embedded_worker_id,
                             int64_t service_worker_version_id,
                             const GURL& scope,
                             const GURL& script_url,
                             bool pause_after_download);
  virtual void OnResumeAfterDownload(int embedded_worker_id);
  virtual void OnStopWorker(int embedded_worker_id);
  virtual bool OnMessageToWorker(int thread_id,
                                 int embedded_worker_id,
                                 const IPC::Message& message);

  // Called to setup mojo for a new embedded worker. Override to register
  // interfaces the worker should expose to the browser.
  virtual void OnSetupMojo(
      int thread_id,
      service_manager::InterfaceRegistry* interface_registry);

  // On*Event handlers. Called by the default implementation of
  // OnMessageToWorker when events are sent to the embedded
  // worker. By default they just return success via
  // SimulateSendReplyToBrowser.
  virtual void OnActivateEvent(int embedded_worker_id, int request_id);
  virtual void OnExtendableMessageEvent(int embedded_worker_id, int request_id);
  virtual void OnInstallEvent(int embedded_worker_id, int request_id);
  virtual void OnFetchEvent(int embedded_worker_id,
                            int fetch_event_id,
                            const ServiceWorkerFetchRequest& request,
                            mojom::FetchEventPreloadHandlePtr preload_handle,
                            const FetchCallback& callback);
  virtual void OnPushEvent(int embedded_worker_id,
                           int request_id,
                           const PushEventPayload& payload);

  // These functions simulate sending an EmbeddedHostMsg message to the
  // browser.
  void SimulateWorkerReadyForInspection(int embedded_worker_id);
  void SimulateWorkerScriptCached(int embedded_worker_id);
  void SimulateWorkerScriptLoaded(int embedded_worker_id);
  void SimulateWorkerThreadStarted(int thread_id, int embedded_worker_id);
  void SimulateWorkerScriptEvaluated(int embedded_worker_id, bool success);
  void SimulateWorkerStarted(int embedded_worker_id);
  void SimulateWorkerStopped(int embedded_worker_id);
  void SimulateSend(IPC::Message* message);

  EmbeddedWorkerRegistry* registry();

 private:
  using InterfaceRegistryAndProvider =
      std::pair<std::unique_ptr<service_manager::InterfaceRegistry>,
                std::unique_ptr<service_manager::InterfaceProvider>>;

  class MockEmbeddedWorkerSetup;
  class MockFetchEventDispatcher;

  void OnStartWorkerStub(const EmbeddedWorkerStartParams& params);
  void OnResumeAfterDownloadStub(int embedded_worker_id);
  void OnStopWorkerStub(int embedded_worker_id);
  void OnMessageToWorkerStub(int thread_id,
                             int embedded_worker_id,
                             const IPC::Message& message);
  void OnActivateEventStub(int request_id);
  void OnExtendableMessageEventStub(
      int request_id,
      const ServiceWorkerMsg_ExtendableMessageEvent_Params& params);
  void OnInstallEventStub(int request_id);
  void OnFetchEventStub(int thread_id,
                        int fetch_event_id,
                        const ServiceWorkerFetchRequest& request,
                        mojom::FetchEventPreloadHandlePtr preload_handle,
                        const FetchCallback& callback);
  void OnPushEventStub(int request_id, const PushEventPayload& payload);
  void OnSetupMojoStub(
      int thread_id,
      service_manager::mojom::InterfaceProviderRequest services,
      service_manager::mojom::InterfaceProviderPtr exposed_services);

  MessagePortMessageFilter* NewMessagePortMessageFilter();

  std::unique_ptr<service_manager::InterfaceRegistry> CreateInterfaceRegistry(
      MockRenderProcessHost* rph);

  std::unique_ptr<TestBrowserContext> browser_context_;
  std::unique_ptr<MockRenderProcessHost> render_process_host_;
  std::unique_ptr<MockRenderProcessHost> new_render_process_host_;

  scoped_refptr<ServiceWorkerContextWrapper> wrapper_;

  IPC::TestSink sink_;
  IPC::TestSink inner_sink_;

  std::vector<std::unique_ptr<MockEmbeddedWorkerInstanceClient>>
      mock_instance_clients_;
  size_t mock_instance_clients_next_index_;

  int next_thread_id_;
  int mock_render_process_id_;
  int new_mock_render_process_id_;

  std::unique_ptr<service_manager::InterfaceRegistry>
      render_process_interface_registry_;
  std::unique_ptr<service_manager::InterfaceRegistry>
      new_render_process_interface_registry_;

  std::map<int, int64_t> embedded_worker_id_service_worker_version_id_map_;
  std::map<int /* thread_id */, int /* embedded_worker_id */>
      thread_id_embedded_worker_id_map_;

  // Stores the InterfaceRegistry/InterfaceProviders that are associated with
  // each individual service worker.
  base::hash_map<int, InterfaceRegistryAndProvider>
      thread_id_service_registry_map_;

  // Updated each time MessageToWorker message is received.
  int current_embedded_worker_id_;

  std::vector<scoped_refptr<MessagePortMessageFilter>>
      message_port_message_filters_;

  base::WeakPtrFactory<EmbeddedWorkerTestHelper> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerTestHelper);
};

template <typename MockType, typename... Args>
MockType* EmbeddedWorkerTestHelper::CreateAndRegisterMockInstanceClient(
    Args&&... args) {
  std::unique_ptr<MockType> mock =
      base::MakeUnique<MockType>(std::forward<Args>(args)...);
  MockType* mock_rawptr = mock.get();
  RegisterMockInstanceClient(std::move(mock));
  return mock_rawptr;
}

}  // namespace content

#endif  // CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_TEST_HELPER_H_


text:
class DropOptioningsAndOptionLevels < ActiveRecord::Migration[4.2]
  def up
    drop_table :optionings
    drop_table :option_levels
  end

  def down
  end
end


text:
package com.xmomen.module.base.model;

import java.io.Serializable;

public class CouponCategoryRefModel implements Serializable{
	private Integer cdItemId;
	private String itemName;
	private String itemCode;
	private String categoryName;
	private Integer count;
	public Integer getCount() {
		return count;
	}

	public void setCount(Integer count) {
		this.count = count;
	}

	public String getItemName() {
		return itemName;
	}

	public void setItemName(String itemName) {
		this.itemName = itemName;
	}

	public String getItemCode() {
		return itemCode;
	}

	public void setItemCode(String itemCode) {
		this.itemCode = itemCode;
	}

	public String getCategoryName() {
		return categoryName;
	}

	public void setCategoryName(String categoryName) {
		this.categoryName = categoryName;
	}

	public Integer getCdItemId() {
		return cdItemId;
	}

	public void setCdItemId(Integer cdItemId) {
		this.cdItemId = cdItemId;
	}

}


text:
<?php
if(isset($user))
    app('navigator')
            ->activate('posts', 'owned')
            ->set_page_heading('Danh sách bài viết của ' . $user->name)
            ->set_breadcrumb('admin', 'posts');
else
    app('navigator')
            ->activate('posts', 'index')
            ->set_page_heading('Danh sách bài viết')
            ->set_breadcrumb('admin', 'posts');
?>

@extends('partials.admin._layout')

@section('content')

                                <input placeholder="Tìm bài viết" id="search-input" type="text" class="form-control input-sm" value="{{ $filter_search_term }}">

                                    <button type="button" class="btn-white btn btn-sm"></button>

                            <select id="category_id" name="category_id" class="category form-control">
                                <option value="*">Tất cả chuyên mục</option>
                                @foreach($categories as $cat)
                                    @if($filter_category == $cat['id'])
                                        <option value="{{ $cat['id'] }}" selected="selected">{{ $cat['name'] }}</option>
                                    @else
                                        <option value="{{ $cat['id'] }}">{{ $cat['name'] }}</option>
                                    @endif
                                @endforeach
                            </select>

                                            <input type="radio" name="status_type" {{ $filter_status_type == 'pending' ? 'checked' : '' }} value="pending"> Đợi duyệt

                                            <input type="radio" name="status_type" {{  $filter_status_type == 'approved' ? 'checked' : '' }} value="approved"> Đã duyệt

                                            <input type="radio" name="status_type" {{  $filter_status_type == 'draft' ? 'checked' : '' }} value="draft"> Nháp

                                            <input type="radio" name="status_type" {{  $filter_status_type == 'trash' ? 'checked' : '' }} value="trash"> Rác

Danh sách bài viết

perPage() }}">

                            Tiêu đề
                            Tác giả
                            Chuyên mục
                            Phản hồi
                            Bình luận
                            Lượt xem
                            Ngày đăng

                        @foreach($posts as $post)

                                    {{ $post->title }}

                                        @if(Gate::allows('approvePost') ||
                                            Gate::allows('approveDraftPost', $post) ||
                                            Gate::allows('approveOwnedDraftPost', $post) ||
                                            Gate::allows('approvePendingPost', $post) ||
                                            Gate::allows('approveOwnedPendingPost', $post) ||
                                            Gate::allows('approveCollaboratorPost', $post) ||
                                            Gate::allows('approveCollaboratorDraftPost', $post) ||
                                            Gate::allows('approveCollaboratorPendingPost', $post))
                                            @if($filter_status_type == 'pending' || $filter_status_type == 'draft')

 $post->id]) }}" class="text-success">Duyệt

                                            @endif
                                        @endif
                                        @can('unapprovePost')
                                            @if($filter_status_type == 'approved'  || $filter_status_type == 'draft')

 $post->id]) }}" class="text-success">Bỏ duyệt

                                            @endif
                                        @endcan

                                        @if($filter_status_type == 'trash')
                                            @can('destroyPost')

title }}" data-post_id="{{ $post->id }}" class="text-danger">Xóa

                                            @endcan
                                        @else
                                            @if(Gate::allows('trashPost') || Gate::allows('trashOwnedPost', $post))

 $post->id]) }}" class="text-danger">Rác

                                            @endif
                                        @endif

                                        @if(Gate::allows('updatePost') || Gate::allows('updateOwnedPost', $post))

 $post->id]) }}">Sửa

                                        @endif

                                {{ $post->user->role->label }} - {{ $post->user->name }}
                                {{ $post->category != null ? $post->category->name : '' }}

                                    @can('indexFeedback')
                                         $post->id]) }}">{{ $post->feedbacksCount }}
                                    @else
                                        {{ $post->feedbacksCount }}
                                    @endcan

                                {{ $post->commentsCount }}
                                {{ $post->view }}
                                {{ $post->published_at }}

                        @endforeach

{!! $posts->links() !!}

    @can('destroyPost')
        @section('post-delete_inputs')
            <input name="post_id" type="hidden"/>
        @endsection
        @include('admin.partials._prompt',
            [
                'id' => 'post-delete',
                'method' => 'post',
                'action' => URL::action('PostsController@destroy'),
                'title' => 'Xác nhận',
                'message' => 'Bạn có chắc chắn muốn xóa bài viết "này" hay không?',
            ])
    @endcan
@endsection

@section('footer-script')

@endsection


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>VERB</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.

VERB: verb

Definition

A verb is a member of the syntactic class of words that typically signal events and actions, can constitute a minimal predicate in a
clause, and govern the number and types of other constituents which may occur in the clause.

Note that the VERB tag covers main verbs (content verbs) and modal verbs but it does not cover auxiliary verbs, for which there is the AUX tag. (Ukrainian modal verbs are not considered auxiliary.) See the description of AUX for more information on the borderline between VERB and AUX.

Ukrainian verbs can take the following morphological forms:

Infinitive (this is the citation form)

Finite verb (indicative and imperative forms; conditional is constructed periphrastically). Ukrainian future tense can be formed either analitically, with the help of the auxiliary verb бути  "to be" or syntactically, with the help of endings rooted in the auxiliary verb мати  "to have".

Active and passive adverbial participle

Impersonal form ending with -но/-то. In Slavic languages other than Ukrainian and Polish this form coincides with the neutral passive adjectival participle, but in those two languages the participle has a different ending: -не in Ukrainian and -ne in Polish, which is why it is treated as a separate verbal form.

There are participial forms that are tagged as adjectives (ADJ) rather than verbs.
See below for border cases.

A verbal noun can be derived productively from almost every verb (e.g. робити  "to do" → робіння  "doing"). While in other languages a corresponding form may be called gerund and tagged VERB, in Ukrainian it is tagged NOUN. It has always the neuter uk-feat/Gender and it inflects for uk-feat/Number and uk-feat/Case.

Examples

нести  "to carry"

несу, несеш, несе, несемо, несете, несуть  "I carry, you carry, he/she/it carries, we carry, you carry, they carry"

неси, несімо, несіть  "carry" (imperative in different persons and numbers)

ніс, несла, несло, несли  "carried" (past tense forms in different genders and numbers)

несено "(it was/somebody) carried" (passive impersonal form)

несучи, нісши  "carrying" (present and past adverbial participles)

Border cases

Passive and active adjectival participles are non-finite verb forms that share properties of verbs and adjectives.

Passive adjectival participle is used to construct passive voice: несений, несена, несене, несені  "carried" (passive participle in different genders and numbers). It is also used separately as an adjective: ношений, драний  "carried, torn/ragged". Their meaning is almost identical but the usage slightly varies. Both groups can be used in nominal predication with copula. Only true participles (verbs) can be used to form the passive voice (but it may be sometimes difficult to distinguish from copula constructions, see AUX). On the other hand, the participial adjectives inflect for case and thus can modify nouns.

Active participle (it is considered ungrammatical but still used occasionally, which is why it is encoded): несучий, несуча, несуче, несучі  "carrying" (present adjectival participle in different genders and numbers).

VERB in other languages:

[bej]

[bg]

[bm]

[cs]

[cy]

[da]

[el]

[en]

[ess]

[et]

[eu]

[fi]

[fro]

[fr]

[ga]

[grc]

[hu]

[hy]

[it]

[ja]

[kk]

[kpv]

[myv]

[no]

[pcm]

[pt]

[qpm]

[ru]

[sl]

[sv]

[tr]

[tt]

[uk]

[u]

[urj]

[yue]

[zh]

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


text:
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace MaterialDesignColors.WpfExample
{
    /// <summary>
    /// Interaction logic for Home.xaml
    /// </summary>
    public partial class Home : UserControl
    {
        public Home()
        {
            InitializeComponent();
        }

        private void GitHubButton_OnClick(object sender, RoutedEventArgs e)
        {
            Process.Start(ConfigurationManager.AppSettings["GitHub"]);
        }

        private void TwitterButton_OnClick(object sender, RoutedEventArgs e)
        {
            Process.Start("https://twitter.com/James_Willock");
        }

        private void ChatButton_OnClick(object sender, RoutedEventArgs e)
        {
            Process.Start("https://gitter.im/ButchersBoy/MaterialDesignInXamlToolkit");
        }

        private void EmailButton_OnClick(object sender, RoutedEventArgs e)
        {
            Process.Start("mailto://james@dragablz.net");
        }

        private void DonateButton_OnClick(object sender, RoutedEventArgs e)
        {
            Process.Start("https://pledgie.com/campaigns/31029");
        }
    }
}