text:
"""Tests for comments notifier"""
from django.core.mail import EmailMessage
import pytest

from notifications.factories import NotificationSettingsFactory
from notifications.models import EmailNotification
from notifications.notifiers import moderator_posts
from notifications.models import NOTIFICATION_TYPE_MODERATOR, FREQUENCY_IMMEDIATE
from open_discussions.test_utils import any_instance_of

pytestmark = [pytest.mark.django_db]

def test_create_moderator_post_event():
    """Tests that create_moderator_post_event works correctly"""
    notification_setting = NotificationSettingsFactory.create(immediate=True)
    notifier = moderator_posts.ModeratorPostsNotifier(notification_setting)
    event = notifier.create_moderator_post_event(notification_setting.user, "post_id")

    assert event.post_id == "post_id"
    assert event.email_notification is not None

@pytest.mark.betamax
def test_send_notification(
    mocker,
    reddit_factories,
    private_channel_and_contributor,
    staff_api,  # pylint:disable=unused-argument
):
    """Tests send_notification"""
    channel, user = private_channel_and_contributor
    notification_setting = NotificationSettingsFactory.create(
        user=user,
        trigger_frequency=FREQUENCY_IMMEDIATE,
        notification_type=NOTIFICATION_TYPE_MODERATOR,
        via_email=True,
    )
    notifier = moderator_posts.ModeratorPostsNotifier(notification_setting)

    send_messages_mock = mocker.patch("mail.api.send_messages")

    post = reddit_factories.text_post("just a post", user, channel=channel)

    event = notifier.create_moderator_post_event(notification_setting.user, post.id)
    note = event.email_notification
    note.state = EmailNotification.STATE_SENDING
    note.save()

    notifier.send_notification(note)

    send_messages_mock.assert_called_once_with([any_instance_of(EmailMessage)])


text:
require 'open-uri'
require 'net/http'
require 'nokogiri'

module PageHub
module Markdown

  # Downloads remote textual resources from websites
  # and allows for content extraction from HTML pages
  # so it can be neatly embedded in another page.
  module Embedder
    class EmbeddingError    < RuntimeError; end
    class InvalidSizeError  < EmbeddingError; end
    class InvalidTypeError  < EmbeddingError; end

    # Resources whose content-type is not specified in this
    # list will be rejected
    AllowedTypes = [/text\/plain/, /text\/html/, /application\/html/]

    # Resources larger than 1 MByte will be rejected
    MaximumLength = 1 * 1024 * 1024

    # Resources served by any of the hosts specified in this list
    # will be rejected
    FilteredHosts = []

    Timeout = 5

    private

    @@processors = []

    public

    class << self

      # Performs a HEAD request to validate the resource, and if it
      # passes the checks it will be downloaded and processed if
      # any eligible Embedder::Processor is registered.
      #
      # Arguments:
      # 1. raw_uri  the full raw URI of the file to be embedded
      # 2. source   an optional identifier to specify the Processor
      #             that should be used to post-process the content
      # 3. args     options that can be meaningful to the Processor, if any
      #
      # Returns:
      # A string containing the extracted data, or an empty one
      def get_resource(raw_uri, source = "", args = "")
        begin
          uri = URI.parse(raw_uri)

          # reject if the host is banned
          return "" if FilteredHosts.include?(uri.host)

          http = Net::HTTP.new(uri.host, uri.port)
          http.open_timeout = Timeout
          http.read_timeout = Timeout
          http.use_ssl      = (uri.scheme == 'https')

          http.start do

            # get the content type and length
            ctype = ""
            clength = 0
            http.head(uri.path).each { |k,v|
              # puts "#{k} => #{v}"
              ctype = v if k == "content-type"
              clength = v.to_i if k == "content-length"
            }

            raise InvalidTypeError.new ctype if !self.allowed?(ctype)
            raise InvalidSizeError.new clength if clength > MaximumLength

            open(raw_uri) { |f|
              content = f.read

              # invoke processors
              keys = []
              keys << source unless source.empty?
              keys << raw_uri
              @@processors.each { |p|
                if p.applies_to?(keys) then
                  content = p.process(content, raw_uri, args)
                  break
                end
              }

              return content
            }
          end
        rescue EmbeddingError => e
          # we want to escalate these errors
          raise e
        rescue Exception => e
          # mask as a generic EmbeddingError
          raise EmbeddingError.new "generic: #{e.class}##{e.message}"
        end

        ""
      end

      def allowed?(ctype)
        AllowedTypes.each { |t| return true if t.match ctype }
        false
      end

      def register_processor(proc)
        @@processors ||= []
        @@processors << proc
      end

    end # class << self

    class Processor

      # Processors apply to "keys" which can be written manually
      # in Markdown by the user, or are found in the host portion
      # of the resource URI
      #
      # IE, a Github Wiki processor would bind to the keys:
      # "github-wiki", or/and <tt>/github.com.*\/wiki\//</tt>
      #
      # Manual keys are injected after the !include keyword:
      # [!include github-wiki!](https://github.com/some-dude/wiki/Home)
      #
      def initialize(keys)
        @keys = keys
        super()
      end

      def process(content, uri, args = "")
        raise NotImplementedError
      end

      def applies_to?(keys)
        @keys.each { |h| keys.each { |k| return true if h.match k } }
        false
      end

      # Node should be the root node that contains the embedded content,
      # which will be stripped of all attributes and injected with new ones:
      # 1. data-embed-uri containing the URI of the embedded resource
      # 2. data-embed-src the name of the processor used for embedding
      #
      # All children nodes that have an @id attribute will have that attribute
      # removed as well.
      def stamp(node, uri, key)
        node.xpath("//*[@id]").each { |node| node.remove_attribute "id" }
        node.attributes.each_pair { |name,_| node.remove_attribute name }
        node['data-embed-uri'] = uri
        node['data-embed-src'] = key
      end
    end

    # Extracts content from GitHub Wiki pages
    #
    # Bound keys:
    # * "github-wiki"
    # * URI("[...]github.com/[...]/wiki/[...]")
    #
    class GithubWikiProcessor < Processor
      def initialize()
        super(["github-wiki", /github.com.*\/wiki\//])
      end

      # Returns the content of the node

,
      # it will also remove all id attributes of all content nodes.
      #
      # Supported options:
      # 1. reduce-headings: all heading nodes (
 through
) will be
      # stepped one level, so h1 becomes h2, etc.
      def process(content, uri, args = "")
        html_doc = Nokogiri::HTML(content) do |config| config.noerror end

        node = html_doc.xpath("//div[@class='markdown-body']").first

        stamp(node, uri, 'github-wiki')

        if args.include?("reduce-headings") then
          5.downto(1) { |level|
            node.xpath("//h#{level}").each { |heading_node|
              heading_node.name = "h#{level+1}"
            }
          }
        end

        node.to_s
      end

    end

    # Extracts content from PageHub shared documents
    #
    # Bound keys:
    # * "pagehub"
    # * URI([...]pagehub.org/[...])
    class PageHubProcessor < Processor
      def initialize()
        super(["pagehub", /pagehub.org/])
      end

      def process(content, uri, args = "")
        html_doc = Nokogiri::HTML(content) do |config| config.noerror end
        node = html_doc.xpath("//div[@id='content']").first
        node.xpath('div[@id="breadcrumbs"]').remove
        node.xpath('div[@id="bottom"]').remove
        stamp(node, uri, 'pagehub')
        node.to_s
      end
    end

    register_processor(GithubWikiProcessor.new)
    register_processor(PageHubProcessor.new)

    MATCH = /^\B\[\![include|embed]\s?(.*)\!\]\((.*)\)/
  end # Embedder module

  add_processor :pre_render, lambda {|str|
    # Embed remote references, if any
    str.gsub!(Embedder::MATCH) {
      content = ""

      uri = $2

      # parse the content source and args, if any
      source = ($1 || "").split.first || ""
      args = ($1 || "").split || []
      args = args[1..args.length].join(' ') unless args.empty?

      begin
        content = Embedder.get_resource(uri, source, args)
        content.gsub!(Embedder::MATCH) {
          source, uri = ($1 || '').split.first, $2

          s = "[See this indirectly embedded resource"
          s << source.empty? ? '' : " from '#{source}'"
          s << ": #{uri}]"
          s << "(#{uri})"
          s
        }
      rescue Embedder::InvalidSizeError => e
        content << "**Embedding error**: the file you tried to embed is too big - #{e.message.to_i} bytes."
        content << " (**Source**: [#{$2}](#{$2}))\n\n"
      rescue Embedder::InvalidTypeError => e
        content << "**Embedding error**: the file type you tried to embed (`#{e.message}`) is not supported."
        content << " (**Source**: [#{$2}](#{$2}))\n\n"
      rescue Embedder::EmbeddingError => e
        content << "**Embedding error**: #{e.message}."
        content << " (**Source**: [#{$2}](#{$2}))\n\n"
      end

      # content = "
#{content.to_s.to_markdown}
".to_markdown
      # content = "#{content}"
      content
    }

    str
  }

end # Markdown module
end # PageHub module

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Class required_option</title>
<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../../program_options/reference.html#header.boost.program_options.errors_hpp" title="Header <boost/program_options/errors.hpp>">
<link rel="prev" href="reading_file.html" title="Class reading_file">
<link rel="next" href="too_many_1_3_32_9_5_1_1_15.html" title="Class too_many_positional_options_error">

Home
Libraries
People
FAQ
More

Class required_option

boost::program_options::required_option

Synopsis

// In header: <boost/program_options/errors.hpp>

class required_option : public boost::program_options::error_with_option_name {
public:
  // construct/copy/destruct
  required_option(const std::string &);
  ~required_option();
};

Description

Class thrown when a required/mandatory option is missing

required_option
        public
       construct/copy/destruct

required_option(const std::string & option_name);

~required_option();

Copyright © 2002-2004 Vladimir Prus
Distributed under the Boost Software License, Version 1.0.
      (See accompanying file LICENSE_1_0.txt or copy at
      http://www.boost.org/LICENSE_1_0.txt)


text:
package org.apache.asterix.test.server;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class FileTestServer implements ITestServer {
    protected String[] paths;
    protected final int port;
    protected ServerSocket serverSocket;
    protected Thread listenerThread;

    public FileTestServer(int port) {
        this.port = port;
    }

    @Override
    public void configure(String[] args) {
        this.paths = args;
    }

    @Override
    public void start() throws IOException {
        serverSocket = new ServerSocket(port);
        listenerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!serverSocket.isClosed()) {
                    try (Socket socket = serverSocket.accept(); OutputStream os = socket.getOutputStream()) {
                        byte[] chunk = new byte[1024];
                        for (String path : paths) {
                            try (FileInputStream fin = new FileInputStream(new File(path))) {
                                int read = fin.read(chunk);
                                while (read > 0) {
                                    os.write(chunk, 0, read);
                                    read = fin.read(chunk);
                                }
                            }
                        }
                    } catch (IOException e) {
                        // Do nothing. This means the socket was closed for some reason.
                        // There is nothing to do here except try to close the socket and see if the
                        // server is still listening!
                        // This also could be due to the close() call
                    }
                }

            }
        });
        listenerThread.start();
    }

    @Override
    public void stop() throws IOException, InterruptedException {
        if (serverSocket.isBound()) {
            serverSocket.close();
            if (listenerThread.isAlive()) {
                listenerThread.join();
            }
        }
    }
}


text:
<?php

return [
    /*
    |--------------------------------------------------------------------------
    | Default Serializer
    |--------------------------------------------------------------------------
    |
    | The default serializer to be used when performing a transformation. It
    | may be left empty to use Fractal's default one. This can either be a
    | string or a League\Fractal\Serializer\SerializerAbstract subclass.
    |
    */

    'default_serializer' => League\Fractal\Serializer\JsonApiSerializer::class,

    /*
    |--------------------------------------------------------------------------
    | Auto Includes
    |--------------------------------------------------------------------------
    |
    | If enabled Fractal will automatically add the includes who's
    | names are present in the `include` request parameter.
    |
    */

    'auto_includes' => [
        'enabled' => true,
        'request_key' => 'include',
    ],
];


text:
<?php

namespace shiyang\masonry;

use yii\web\AssetBundle;

/**
 * @link http://www.shiyang.me
 * @author Shiyang <dr@shiyang.me>
 */

class ImagesLoadedAsset extends AssetBundle
{
    public $sourcePath = '@bower/imagesloaded';

    public $css = [];

    public $js = [
            'imagesloaded.pkgd.min.js'
    ];

    public $depends = array(
        'yii\web\JqueryAsset',
    );
}


text:
<!doctype html>

	<meta charset="utf-8">
	<title>66 KINOS Extra</title>
	<meta name="viewport" content="width=device-width, initial-scale=1">

	<link rel="stylesheet" href="main.css">
	<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Merriweather|Montserrat">

			<button id="button-cinema">kino a-z</button>
			<button id="button-city">stadt a-z</button>
			<button id="button-date">datum</button>
			<button id="button-map">karte</button>
			<button id="button-skip">skip</button>

Alle Beiträge sind Ausschnitte aus 66KINOS sowie Rohmaterial und Outtakes.
Die Seite lässt sich am besten auf einem Laptop/Desktop mit einem modernen Browser genießen.


text:
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.ui.tabs;

public interface TabsListener {
  default void selectionChanged(TabInfo oldSelection, TabInfo newSelection) {
  }

  default void beforeSelectionChanged(TabInfo oldSelection, TabInfo newSelection) {
  }

  default void tabRemoved(TabInfo tabToRemove) {
  }

  default void tabsMoved() {
  }

  /**
   * Use {@link TabsListener} directly
   */
  @Deprecated
  class Adapter implements TabsListener {
  }
}


text:
<?php
namespace Portfolio;

class Module
{
    public function getConfig()
    {
        return include __DIR__ . '/config/module.config.php';
    }

    public function getServiceConfig(){
        return include __DIR__ . '/config/service.config.php';
    }
}


text:
/* Deprecated, Ivan Tcholakov, 27-OCT-2014 */

/* DG - 29/11/12 - Align single item with results. General UI Imrpovement */
.chzn-container-single .chzn-single {
  padding: 0 0 0 10px;
}

/* DG - 03/12/12 -chosenImage - position, size and indent text */
.chznImage-container .chzn-results li,
.chznImage-container .chzn-single span {
  background-position: 6px 45%;
  background-size: auto 12px;
  padding-left: 23px;
}

.chznImage-container .chzn-single span {
  background-position: 0px 45%;
  padding-left: 17px;
}

/* End Deprecated */

/* DG - 29/11/12 - Align single item with results. General UI Imrpovement */
.chosen-container-single .chosen-single {
    padding: 0 0 0 10px;
}

/* DG - 03/12/12 -chosenImage - position, size and indent text */
.chosenImage-container .chosen-results li,
.chosenImage-container .chosen-single span {
    background-position: 6px 45%;
    background-size: auto 12px;
    padding-left: 23px;
}

.chosenImage-container .chosen-single span {
    background-position: 0px 45%;
    padding-left: 17px;
}


text:
package springconfiguration;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;

import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import service.StorageService;

import java.util.concurrent.Executor;

@SpringBootApplication
@EnableConfigurationProperties(AppProperties.class)
@EnableJpaRepositories({"biojobs", "converters"})
@EntityScan("biojobs")
@ComponentScan({"service*", "controller", "springconfiguration"})
@EnableAsync
public class Application extends SpringBootServletInitializer {

	private static Class applicationClass = Application.class;

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(applicationClass);
    }

	@Bean
	public Executor asyncExecutor() {
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		executor.setCorePoolSize(2);
		executor.setMaxPoolSize(2);
		executor.setQueueCapacity(5);
		executor.setThreadNamePrefix("LongRunnigJob-");
		executor.initialize();
		return executor;
	}

	@Bean
	CommandLineRunner init(StorageService storageService) {
		return (args) -> {
            storageService.deleteAll();
            storageService.init();
		};
	}
}


text:
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/modules/congestion_controller/include/congestion_controller.h"
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"

namespace webrtc {

class NullBitrateObserver : public CongestionController::Observer,
                            public RemoteBitrateObserver {
 public:
  ~NullBitrateObserver() override {}

  // TODO(minyue): remove this when old OnNetworkChanged is deprecated. See
  // https://bugs.chromium.org/p/webrtc/issues/detail?id=6796
  using CongestionController::Observer::OnNetworkChanged;

  void OnNetworkChanged(uint32_t bitrate_bps,
                        uint8_t fraction_loss,
                        int64_t rtt_ms,
                        int64_t probing_interval_ms) override {}
  void OnReceiveBitrateChanged(const std::vector<uint32_t>& ssrcs,
                               uint32_t bitrate) override {}
};

void FuzzOneInput(const uint8_t* data, size_t size) {
  size_t i = 0;
  if (size < sizeof(int64_t) + sizeof(uint8_t) + sizeof(uint32_t))
    return;
  SimulatedClock clock(data[i++]);
  NullBitrateObserver observer;
  RtcEventLogNullImpl event_log;
  PacketRouter packet_router;
  CongestionController cc(&clock, &observer, &observer, &event_log,
                          &packet_router);
  RemoteBitrateEstimator* rbe = cc.GetRemoteBitrateEstimator(true);
  RTPHeader header;
  header.ssrc = ByteReader<uint32_t>::ReadBigEndian(&data[i]);
  i += sizeof(uint32_t);
  header.extension.hasTransportSequenceNumber = true;
  int64_t arrival_time_ms =
      std::max<int64_t>(ByteReader<int64_t>::ReadBigEndian(&data[i]), 0);
  i += sizeof(int64_t);
  const size_t kMinPacketSize =
      sizeof(size_t) + sizeof(uint16_t) + sizeof(uint8_t);
  while (i + kMinPacketSize < size) {
    size_t payload_size = ByteReader<size_t>::ReadBigEndian(&data[i]) % 1500;
    i += sizeof(size_t);
    header.extension.transportSequenceNumber =
        ByteReader<uint16_t>::ReadBigEndian(&data[i]);
    i += sizeof(uint16_t);
    rbe->IncomingPacket(arrival_time_ms, payload_size, header);
    clock.AdvanceTimeMilliseconds(5);
    arrival_time_ms += ByteReader<uint8_t>::ReadBigEndian(&data[i]);
    arrival_time_ms += sizeof(uint8_t);
  }
  rbe->Process();
}
}  // namespace webrtc


text:
namespace ozz {
// Forward declaration of math structures.
namespace math {
struct SimdQuaternion;
}

namespace animation {

// ozz::animation::IKAimJob rotates a joint so it aims at a target. Joint aim
// direction and up vectors can be different from joint axis. The job computes
// the transformation (rotation) that needs to be applied to the joints such
// that a provided forward vector (in joint local-space) aims at the target
// position (in skeleton model-space). Up vector (in joint local-space) is also
// used to keep the joint oriented in the same direction as the pole vector.
// The job also exposes an offset (in joint local-space) from where the forward
// vector should aim the target.
// Result is unstable if joint-to-target direction is parallel to pole vector,
// or if target is too close to joint position.
struct IKAimJob {
  // Default constructor, initializes default values.
  IKAimJob();

  // Validates job parameters. Returns true for a valid job, or false otherwise:
  // -if output quaternion pointer is nullptr
  bool Validate() const;

  // Runs job's execution task.
  // The job is validated before any operation is performed, see Validate() for
  // more details.
  // Returns false if *this job is not valid.
  bool Run() const;

  // Job input.

  // Target position to aim at, in model-space
  math::SimdFloat4 target;

  // Joint forward axis, in joint local-space, to be aimed at target position.
  // This vector shall be normalized, otherwise validation will fail.
  // Default is x axis.
  math::SimdFloat4 forward;

  // Offset position from the joint in local-space, that will aim at target.
  math::SimdFloat4 offset;

  // Joint up axis, in joint local-space, used to keep the joint oriented in the
  // same direction as the pole vector. Default is y axis.
  math::SimdFloat4 up;

  // Pole vector, in model-space. The pole vector defines the direction
  // the up should point to.  Note that IK chain orientation will flip when
  // target vector and the pole vector are aligned/crossing each other. It's
  // caller responsibility to ensure that this doesn't happen.
  math::SimdFloat4 pole_vector;

  // Twist_angle rotates joint around the target vector.
  // Default is 0.
  float twist_angle;

  // Weight given to the IK correction clamped in range [0,1]. This allows to
  // blend / interpolate from no IK applied (0 weight) to full IK (1).
  float weight;

  // Joint model-space matrix.
  const math::Float4x4* joint;

  // Job output.

  // Output local-space joint correction quaternion. It needs to be multiplied
  // with joint local-space quaternion.
  math::SimdQuaternion* joint_correction;

  // Optional boolean output value, set to true if target can be reached with IK
  // computations. Target is considered not reachable when target is between
  // joint and offset position.
  bool* reached;
};
}  // namespace animation
}  // namespace ozz
#endif  // OZZ_OZZ_ANIMATION_RUNTIME_IK_AIM_JOB_H_


text:
package io.renren;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

/**
 * renren-api
 *
 * @author Mark sunlightcs@gmail.com
 */
@SpringBootApplication
public class ApiApplication extends SpringBootServletInitializer {

	public static void main(String[] args) {
		SpringApplication.run(ApiApplication.class, args);
	}

	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
		return application.sources(ApiApplication.class);
	}
}


text:
Learn how to import from jagged array in VB.NET with this source code sample. ByteScout Spreadsheet SDK can import from jagged array. It can be used from VB.NET. ByteScout Spreadsheet SDK is the SDK to create, read, modify and calculate spreadsheets. Formula calculations are supported, import and export to and from JSON, CSV, XML, databases, arrays.

You will save a lot of time on writing and testing code as you may just take the VB.NET code from ByteScout Spreadsheet SDK for import from jagged array below and use it in your application. Just copy and paste the code into your VB.NET application's code and follow the instruction. Enjoy writing a code with ready-to-use sample VB.NET codes.

Our website provides trial version of ByteScout Spreadsheet SDK for free. It also includes documentation and source code samples.

## REQUEST FREE TECH SUPPORT

[Click here to get in touch](https://bytescout.zendesk.com/hc/en-us/requests/new?subject=ByteScout%20Spreadsheet%20SDK%20Question)

or just send email to [support@bytescout.com](mailto:support@bytescout.com?subject=ByteScout%20Spreadsheet%20SDK%20Question)

## ON-PREMISE OFFLINE SDK

[Get Your 60 Day Free Trial](https://bytescout.com/download/web-installer?utm_source=github-readme)
[Explore SDK Docs](https://bytescout.com/documentation/index.html?utm_source=github-readme)
[Sign Up For Online Training](https://academy.bytescout.com/)

## ON-DEMAND REST WEB API

[Get your API key](https://pdf.co/documentation/api?utm_source=github-readme)
[Explore Web API Documentation](https://pdf.co/documentation/api?utm_source=github-readme)
[Explore Web API Samples](https://github.com/bytescout/ByteScout-SDK-SourceCode/tree/master/PDF.co%20Web%20API)

## VIDEO REVIEW

[https://www.youtube.com/watch?v=nm_7I0PN1TY](https://www.youtube.com/watch?v=nm_7I0PN1TY)

<!-- code block begin -->

##### ****ImportFromJaggedArray.VS2005.vbproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <ProductVersion>8.0.50727</ProductVersion>
    <SchemaVersion>
    </SchemaVersion>
    <ProjectGuid>{1C374055-F38F-429B-AF66-B2E8D78C76F5}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <StartupObject>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.Module1</StartupObject>
    <RootNamespace>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</RootNamespace>
    <AssemblyName>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</AssemblyName>
    <FileAlignment>512</FileAlignment>
    <MyType>Console</MyType>
    <TargetFrameworkProfile>
    </TargetFrameworkProfile>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <DefineDebug>true</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <OutputPath>bin\Debug\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <DefineDebug>false</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup>
    <OptionExplicit>On</OptionExplicit>
  </PropertyGroup>
  <PropertyGroup>
    <OptionCompare>Binary</OptionCompare>
  </PropertyGroup>
  <PropertyGroup>
    <OptionStrict>Off</OptionStrict>
  </PropertyGroup>
  <PropertyGroup>
    <OptionInfer>On</OptionInfer>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.Spreadsheet, Version=2.3.0.750, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\lib\Bytescout.Spreadsheet.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Deployment" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
  </ItemGroup>
  <ItemGroup>
    <Import Include="Microsoft.VisualBasic" />
    <Import Include="System" />
    <Import Include="System.Collections" />
    <Import Include="System.Collections.Generic" />
    <Import Include="System.Data" />
    <Import Include="System.Diagnostics" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Module1.vb" />
    <Compile Include="My Project\AssemblyInfo.vb" />
    <Compile Include="My Project\Application.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Application.myapp</DependentUpon>
    </Compile>
    <Compile Include="My Project\Resources.Designer.vb">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="My Project\Settings.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Settings.settings</DependentUpon>
      <DesignTimeSharedInput>True</DesignTimeSharedInput>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="My Project\Resources.resx">
      <Generator>VbMyResourcesResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.vb</LastGenOutput>
      <CustomToolNamespace>My.Resources</CustomToolNamespace>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <None Include="My Project\Application.myapp">
      <Generator>MyApplicationCodeGenerator</Generator>
      <LastGenOutput>Application.Designer.vb</LastGenOutput>
    </None>
    <None Include="My Project\Settings.settings">
      <Generator>SettingsSingleFileGenerator</Generator>
      <CustomToolNamespace>My</CustomToolNamespace>
      <LastGenOutput>Settings.Designer.vb</LastGenOutput>
    </None>
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.VisualBasic.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### ****ImportFromJaggedArray.VS2008.vbproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <ProductVersion>9.0.30729</ProductVersion>
    <SchemaVersion>
    </SchemaVersion>
    <ProjectGuid>{1C374055-F38F-429B-AF66-B2E8D78C76F5}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <StartupObject>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.Module1</StartupObject>
    <RootNamespace>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</RootNamespace>
    <AssemblyName>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</AssemblyName>
    <FileAlignment>512</FileAlignment>
    <MyType>Console</MyType>
    <TargetFrameworkProfile>
    </TargetFrameworkProfile>
    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <DefineDebug>true</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <OutputPath>bin\Debug\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <DefineDebug>false</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup>
    <OptionExplicit>On</OptionExplicit>
  </PropertyGroup>
  <PropertyGroup>
    <OptionCompare>Binary</OptionCompare>
  </PropertyGroup>
  <PropertyGroup>
    <OptionStrict>Off</OptionStrict>
  </PropertyGroup>
  <PropertyGroup>
    <OptionInfer>On</OptionInfer>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.Spreadsheet, Version=2.3.0.750, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\lib\Bytescout.Spreadsheet.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Deployment" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
  </ItemGroup>
  <ItemGroup>
    <Import Include="Microsoft.VisualBasic" />
    <Import Include="System" />
    <Import Include="System.Collections" />
    <Import Include="System.Collections.Generic" />
    <Import Include="System.Data" />
    <Import Include="System.Diagnostics" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Module1.vb" />
    <Compile Include="My Project\AssemblyInfo.vb" />
    <Compile Include="My Project\Application.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Application.myapp</DependentUpon>
    </Compile>
    <Compile Include="My Project\Resources.Designer.vb">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="My Project\Settings.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Settings.settings</DependentUpon>
      <DesignTimeSharedInput>True</DesignTimeSharedInput>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="My Project\Resources.resx">
      <Generator>VbMyResourcesResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.vb</LastGenOutput>
      <CustomToolNamespace>My.Resources</CustomToolNamespace>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <None Include="My Project\Application.myapp">
      <Generator>MyApplicationCodeGenerator</Generator>
      <LastGenOutput>Application.Designer.vb</LastGenOutput>
    </None>
    <None Include="My Project\Settings.settings">
      <Generator>SettingsSingleFileGenerator</Generator>
      <CustomToolNamespace>My</CustomToolNamespace>
      <LastGenOutput>Settings.Designer.vb</LastGenOutput>
    </None>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.VisualBasic.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### ****ImportFromJaggedArray.VS2010.vbproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <SchemaVersion>
    </SchemaVersion>
    <ProjectGuid>{1C374055-F38F-429B-AF66-B2E8D78C76F5}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <StartupObject>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.Module1</StartupObject>
    <RootNamespace>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</RootNamespace>
    <AssemblyName>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</AssemblyName>
    <FileAlignment>512</FileAlignment>
    <MyType>Console</MyType>
    <TargetFrameworkProfile>
    </TargetFrameworkProfile>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <DefineDebug>true</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <OutputPath>bin\Debug\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <DefineDebug>false</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup>
    <OptionExplicit>On</OptionExplicit>
  </PropertyGroup>
  <PropertyGroup>
    <OptionCompare>Binary</OptionCompare>
  </PropertyGroup>
  <PropertyGroup>
    <OptionStrict>Off</OptionStrict>
  </PropertyGroup>
  <PropertyGroup>
    <OptionInfer>On</OptionInfer>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.Spreadsheet, Version=2.3.0.750, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\lib\Bytescout.Spreadsheet.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Deployment" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
  </ItemGroup>
  <ItemGroup>
    <Import Include="Microsoft.VisualBasic" />
    <Import Include="System" />
    <Import Include="System.Collections" />
    <Import Include="System.Collections.Generic" />
    <Import Include="System.Data" />
    <Import Include="System.Diagnostics" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Module1.vb" />
    <Compile Include="My Project\AssemblyInfo.vb" />
    <Compile Include="My Project\Application.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Application.myapp</DependentUpon>
    </Compile>
    <Compile Include="My Project\Resources.Designer.vb">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="My Project\Settings.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Settings.settings</DependentUpon>
      <DesignTimeSharedInput>True</DesignTimeSharedInput>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="My Project\Resources.resx">
      <Generator>VbMyResourcesResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.vb</LastGenOutput>
      <CustomToolNamespace>My.Resources</CustomToolNamespace>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <None Include="My Project\Application.myapp">
      <Generator>MyApplicationCodeGenerator</Generator>
      <LastGenOutput>Application.Designer.vb</LastGenOutput>
    </None>
    <None Include="My Project\Settings.settings">
      <Generator>SettingsSingleFileGenerator</Generator>
      <CustomToolNamespace>My</CustomToolNamespace>
      <LastGenOutput>Settings.Designer.vb</LastGenOutput>
    </None>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.VisualBasic.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### ****ImportFromJaggedArray.VS2012.vbproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <SchemaVersion>
    </SchemaVersion>
    <ProjectGuid>{1C374055-F38F-429B-AF66-B2E8D78C76F5}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <StartupObject>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.Module1</StartupObject>
    <RootNamespace>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</RootNamespace>
    <AssemblyName>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</AssemblyName>
    <FileAlignment>512</FileAlignment>
    <MyType>Console</MyType>
    <TargetFrameworkProfile>
    </TargetFrameworkProfile>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <DefineDebug>true</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <OutputPath>bin\Debug\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <DefineDebug>false</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup>
    <OptionExplicit>On</OptionExplicit>
  </PropertyGroup>
  <PropertyGroup>
    <OptionCompare>Binary</OptionCompare>
  </PropertyGroup>
  <PropertyGroup>
    <OptionStrict>Off</OptionStrict>
  </PropertyGroup>
  <PropertyGroup>
    <OptionInfer>On</OptionInfer>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.Spreadsheet, Version=2.3.0.750, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\lib\Bytescout.Spreadsheet.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Deployment" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
  </ItemGroup>
  <ItemGroup>
    <Import Include="Microsoft.VisualBasic" />
    <Import Include="System" />
    <Import Include="System.Collections" />
    <Import Include="System.Collections.Generic" />
    <Import Include="System.Data" />
    <Import Include="System.Diagnostics" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Module1.vb" />
    <Compile Include="My Project\AssemblyInfo.vb" />
    <Compile Include="My Project\Application.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Application.myapp</DependentUpon>
    </Compile>
    <Compile Include="My Project\Resources.Designer.vb">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="My Project\Settings.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Settings.settings</DependentUpon>
      <DesignTimeSharedInput>True</DesignTimeSharedInput>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="My Project\Resources.resx">
      <Generator>VbMyResourcesResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.vb</LastGenOutput>
      <CustomToolNamespace>My.Resources</CustomToolNamespace>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <None Include="My Project\Application.myapp">
      <Generator>MyApplicationCodeGenerator</Generator>
      <LastGenOutput>Application.Designer.vb</LastGenOutput>
    </None>
    <None Include="My Project\Settings.settings">
      <Generator>SettingsSingleFileGenerator</Generator>
      <CustomToolNamespace>My</CustomToolNamespace>
      <LastGenOutput>Settings.Designer.vb</LastGenOutput>
    </None>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.VisualBasic.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### ****ImportFromJaggedArray.VS2013.vbproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <SchemaVersion>
    </SchemaVersion>
    <ProjectGuid>{1C374055-F38F-429B-AF66-B2E8D78C76F5}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <StartupObject>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.Module1</StartupObject>
    <RootNamespace>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</RootNamespace>
    <AssemblyName>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</AssemblyName>
    <FileAlignment>512</FileAlignment>
    <MyType>Console</MyType>
    <TargetFrameworkProfile>
    </TargetFrameworkProfile>
    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <DefineDebug>true</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <OutputPath>bin\Debug\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <DefineDebug>false</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup>
    <OptionExplicit>On</OptionExplicit>
  </PropertyGroup>
  <PropertyGroup>
    <OptionCompare>Binary</OptionCompare>
  </PropertyGroup>
  <PropertyGroup>
    <OptionStrict>Off</OptionStrict>
  </PropertyGroup>
  <PropertyGroup>
    <OptionInfer>On</OptionInfer>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.Spreadsheet, Version=2.3.0.750, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\lib\Bytescout.Spreadsheet.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Deployment" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
  </ItemGroup>
  <ItemGroup>
    <Import Include="Microsoft.VisualBasic" />
    <Import Include="System" />
    <Import Include="System.Collections" />
    <Import Include="System.Collections.Generic" />
    <Import Include="System.Data" />
    <Import Include="System.Diagnostics" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Module1.vb" />
    <Compile Include="My Project\AssemblyInfo.vb" />
    <Compile Include="My Project\Application.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Application.myapp</DependentUpon>
    </Compile>
    <Compile Include="My Project\Resources.Designer.vb">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="My Project\Settings.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Settings.settings</DependentUpon>
      <DesignTimeSharedInput>True</DesignTimeSharedInput>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="My Project\Resources.resx">
      <Generator>VbMyResourcesResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.vb</LastGenOutput>
      <CustomToolNamespace>My.Resources</CustomToolNamespace>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <None Include="My Project\Application.myapp">
      <Generator>MyApplicationCodeGenerator</Generator>
      <LastGenOutput>Application.Designer.vb</LastGenOutput>
    </None>
    <None Include="My Project\Settings.settings">
      <Generator>SettingsSingleFileGenerator</Generator>
      <CustomToolNamespace>My</CustomToolNamespace>
      <LastGenOutput>Settings.Designer.vb</LastGenOutput>
    </None>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.VisualBasic.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### ****ImportFromJaggedArray.VS2015.vbproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <SchemaVersion>
    </SchemaVersion>
    <ProjectGuid>{1C374055-F38F-429B-AF66-B2E8D78C76F5}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <StartupObject>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.Module1</StartupObject>
    <RootNamespace>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</RootNamespace>
    <AssemblyName>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray</AssemblyName>
    <FileAlignment>512</FileAlignment>
    <MyType>Console</MyType>
    <TargetFrameworkProfile>
    </TargetFrameworkProfile>
    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <DefineDebug>true</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <OutputPath>bin\Debug\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <DefineDebug>false</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DocumentationFile>Bytescout.Spreadsheet.Demo.VBNet.ImportFromJaggedArray.xml</DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup>
    <OptionExplicit>On</OptionExplicit>
  </PropertyGroup>
  <PropertyGroup>
    <OptionCompare>Binary</OptionCompare>
  </PropertyGroup>
  <PropertyGroup>
    <OptionStrict>Off</OptionStrict>
  </PropertyGroup>
  <PropertyGroup>
    <OptionInfer>On</OptionInfer>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.Spreadsheet, Version=2.3.0.750, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\lib\Bytescout.Spreadsheet.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Deployment" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
  </ItemGroup>
  <ItemGroup>
    <Import Include="Microsoft.VisualBasic" />
    <Import Include="System" />
    <Import Include="System.Collections" />
    <Import Include="System.Collections.Generic" />
    <Import Include="System.Data" />
    <Import Include="System.Diagnostics" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Module1.vb" />
    <Compile Include="My Project\AssemblyInfo.vb" />
    <Compile Include="My Project\Application.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Application.myapp</DependentUpon>
    </Compile>
    <Compile Include="My Project\Resources.Designer.vb">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="My Project\Settings.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Settings.settings</DependentUpon>
      <DesignTimeSharedInput>True</DesignTimeSharedInput>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="My Project\Resources.resx">
      <Generator>VbMyResourcesResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.vb</LastGenOutput>
      <CustomToolNamespace>My.Resources</CustomToolNamespace>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <None Include="My Project\Application.myapp">
      <Generator>MyApplicationCodeGenerator</Generator>
      <LastGenOutput>Application.Designer.vb</LastGenOutput>
    </None>
    <None Include="My Project\Settings.settings">
      <Generator>SettingsSingleFileGenerator</Generator>
      <CustomToolNamespace>My</CustomToolNamespace>
      <LastGenOutput>Settings.Designer.vb</LastGenOutput>
    </None>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.VisualBasic.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### ****Module1.vb:**

```
Imports System.IO

Module Module1

    Sub Main()
        Const fileName As String = "VBNetImportFromJaggedArray.xls"

        'Create a new spreadsheet
        Dim spreadsheet As Bytescout.Spreadsheet.Spreadsheet = New Bytescout.Spreadsheet.Spreadsheet

        'Get the data from the jagged array that we want to import
        Dim periodicTable()() As String = GetJaggedArray()

        'Import data into spreadheet
        spreadsheet.ImportFromJaggedArray(periodicTable)

        'Save the spreadsheet
        If (File.Exists(fileName)) Then
            File.Delete(fileName)
        End If
        spreadsheet.SaveAs(fileName)

        'Close spreadsheet
        spreadsheet.Close()

        'Open the spreadsheet
        Process.Start(fileName)
    End Sub

    ''' <summary>
    ''' Creates a jagged array of the period table of elements
    ''' </summary>
    ''' <returns>Jagged array of the periodic table of elements</returns>
    Function GetJaggedArray() As String()()

        Dim periodicTable()() As String = New String()() { _
            New String() {"H", "He"}, _
            New String() {"Li", "Be", "B", "C", "N", "O", "F", "Ne"}, _
            New String() {"Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar"}, _
            New String() {"K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr"}}

        Return periodicTable
    End Function

End Module

```

<!-- code block end -->


text:
var express      = require('express');
var helmet       = require('helmet');
var path         = require('path');
var favicon      = require('serve-favicon');
var logger       = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser   = require('body-parser');
var yaml         = require('read-yaml');

var index = require('./routes/index');

var app = express();
// Implementing Node Security practices
app.use(helmet());
app.disable('x-powered-by');

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');

// uncomment after placing your favicon in /public
app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger(':remote-addr :remote-user :method :url HTTP/:http-version :status :res[content-length] - :response-time ms'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', index);

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  var err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// error handler
app.use(function(err, req, res, next) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get('env') === 'development' ? err : {};
  let context = yaml.sync(__dirname + "/config/config.yaml");
  // render the error page
  res.status(err.status || 500);
  res.render('error', context);
});

module.exports = app;


text:
<?php

namespace Application\AppBundle\Slack\Command;

interface SlackCommand
{
    public function setRegex(string $regex);

    public function matches(string $message) : bool;

    public function getPart(int $index) : string;

    public function configure();

    public function execute(CommandInput $input, CommandOutput $output);
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
Uses of Class com.mxgraph.view.mxGraphView (JGraph X 2.3.0.3 API Specification)
</TITLE>

<META NAME="date" CONTENT="2013-11-18">

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

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

JGraph X 2.3.0.3

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes

Uses of Class
com.mxgraph.view.mxGraphView

Packages that use mxGraphView

com.mxgraph.view
This package implements the graph component, represented by the mxGraph
  class.

Uses of mxGraphView in com.mxgraph.view

Fields in com.mxgraph.view declared as mxGraphView

protected  mxGraphView
mxGraphView.mxCurrentRootChange.view

protected  mxGraphView
mxCellState.view

          Reference to the enclosing graph view.

protected  mxGraphView
mxTemporaryCellStates.view

protected  mxGraphView
mxGraph.view

          Holds the view that caches the cell states.

Methods in com.mxgraph.view that return mxGraphView

protected  mxGraphView
mxGraph.createGraphView()

          Constructs a new view to be used in this graph.

 mxGraphView
mxGraphView.mxCurrentRootChange.getView()

          Returns the graph view where the change happened.

 mxGraphView
mxCellState.getView()

          Returns the enclosing graph view.

 mxGraphView
mxGraph.getView()

          Returns the view that contains the cell states.

Methods in com.mxgraph.view with parameters of type mxGraphView

 void
mxCellState.setView(mxGraphView view)

          Sets the enclosing graph view.

 void
mxGraph.setView(mxGraphView value)

          Sets the view that contains the cell states.

Constructors in com.mxgraph.view with parameters of type mxGraphView

mxCellState(mxGraphView view,
            Object cell,
            Map<String,Object> style)

          Constructs a new object that represents the current state of the given
 cell in the specified view.

mxGraphView.mxCurrentRootChange(mxGraphView view,
                                Object root)

          Constructs a change of the current root in the given view.

mxTemporaryCellStates(mxGraphView view)

          Constructs a new temporary cell states instance.

mxTemporaryCellStates(mxGraphView view,
                      double scale)

          Constructs a new temporary cell states instance.

mxTemporaryCellStates(mxGraphView view,
                      double scale,
                      Object[] cells)

          Constructs a new temporary cell states instance.

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

JGraph X 2.3.0.3

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes

Copyright (c) 2010 Gaudenz Alder. All rights reserved.


text:
class Admin::ApplicationSettingsController < Admin::ApplicationController
  before_filter :set_application_setting

  def show
  end

  def update
    if @application_setting.update_attributes(application_setting_params)
      redirect_to admin_application_settings_path,
        notice: 'Application settings saved successfully'
    else
      render :show
    end
  end

  private

  def set_application_setting
    @application_setting = ApplicationSetting.current
  end

  def application_setting_params
    restricted_levels = params[:application_setting][:restricted_visibility_levels]
    if restricted_levels.nil?
      params[:application_setting][:restricted_visibility_levels] = []
    else
      restricted_levels.map! do |level|
        level.to_i
      end
    end

    params.require(:application_setting).permit(
      :default_projects_limit,
      :default_branch_protection,
      :signup_enabled,
      :signin_enabled,
      :gravatar_enabled,
      :twitter_sharing_enabled,
      :sign_in_text,
      :home_page_url,
      restricted_visibility_levels: []
    )
  end
end


text:
package io.plasmap.js

import io.plasmap.querymodel.{PMCityFromCoordinates, PMCityFromName}
import utest._

object PlasmapJSTest extends TestSuite {

 // val jb = PlasmapJS
  def tests = TestSuite {
//    "can build city from name"-{
//      assert(jb.city("Frankfurt") == PMCityFromName("Frankfurt"))
//    }
//    "can build city from lon lat"-{
//      assert(jb.city(12.0, 1.0) == PMCityFromCoordinates(1.0f, 12.0f))
//    }
//    "can compose various transformers"-{
//      val t1 = jb.city("DD")
//      val t2 = jb.city(23.0, 12.0)
//      val composed = jb.compose(t1, t2)
//      assert(composed == Compose(Seq(CityFromName("DD"), CityFromCoordinates(12.0f, 23.0f))))
//    }
  }
}


text:
angular.module('myApp.directives')
	.directive('lfgHeader', ['user','rdv','tag','lang','redirection','$interval','$filter','$document','$window','$location',
		function(user,rdv,tag,lang,redirection,$interval,$filter,$document,$window,$location) {
			'use strict';
			return {
				scope:{
					'lfgHeader':'='
				},
				link: function($scope, element, attrs) {
					lang.initLang();
					$scope.lang = lang.getCurrent();

					$scope.logout = function(){
						user.logout();
						$scope.userInfo = null;
						$window.location.reload();
					};

					$scope.updateInProgress = false;
					$scope.refreshBungie = function(){
						$scope.updateInProgress = true;
						user.refreshBungie().then(function(data){
							$scope.updateInProgress = false;
						});
					};

					$scope.homeUrl = redirection.getHomePageUrl();
					$scope.rdvUrl = redirection.getHomePageDestinyUrl();
					$scope.partyCreateUrl = redirection.getCreatePartyPageUrl();
					$scope.profilGameUrl = redirection.getProfilGamePageUrl();
					$scope.loginPageUrl = redirection.getLoginPageUrl();
					$scope.registerPageUrl = redirection.getRegisterPageUrl();
					$scope.partyWaitingUrlRoot = redirection.getPartyWaitingUrlRoot();
					$scope.gamesUrl = redirection.getGamesPageUrl();
					$scope.notifUrl = redirection.getNotifPageUrl();
					$scope.matchmakingUrl = redirection.getMatchmakingPageUrl();
					$scope.listUsersUrl = redirection.getListUsersUrl();
					$scope.forumUrl = redirection.getForumUrl();
					$scope.videoUrl = redirection.getVideoUrl();

                    $scope.userInfo = user.get();

					$scope.currentUrl = $location.path();

					/**
					 * autoRefreshDataNotif
					 */
					var refreshDataNotif = function(){

						var promiseNotification = rdv.getNotifications();

						if(promiseNotification === false){
							return;
						}

						promiseNotification.success(function(data){
							if($scope.userInfo === null){
								return;
							}
							$scope.notifications = [];
							$scope.allMyNotifications = data;
							for(var key in $scope.allMyNotifications){
								if($scope.allMyNotifications[key].new === true){
									$scope.notifications.push($scope.allMyNotifications[key]);
								}
							}

							if($scope.notifications.length > 0){
								$document[0].title = '('+$scope.notifications.length+') Esbattle.com';
							} else {
								$document[0].title = 'Esbattle.com';
							}

						});
					};

					var refreshTime = 12000;
					var autoRefreshDataNotif = function(){
						$interval.cancel($scope.intervaNotificationId);

						if (angular.isDefined($scope.intervaNotificationId)) {
							return;
						}

						$scope.intervaNotificationId = $interval(function(){
							refreshDataNotif();
						}, refreshTime);
					};

					refreshDataNotif();
					autoRefreshDataNotif();

				},
				restrict: 'E',
				templateUrl: '/html/directives/lfg-header.html'
			};
		}
	]
);


text:
import os
import sys
import bs4
import collections
import pymongo

def mongo_collection():
    collection = pymongo.MongoClient().poetry.poems
    return collection

def condition(element, transform=None):
    string = element.get_text()
    spaces = ' '.join(string.strip().split()).strip(',')
    if transform:
        return getattr(spaces, transform)()
    else:
        return spaces

def parse_about(about_div):
    result = {}
    for section in about_div.find_all('p', {'class': 'section'}):
        slug = section.find('span', {'class': 'slug'})
        section_name = condition(slug, transform='upper')
        result[section_name] = []
        for a_element in section.find_all('a'):
            result[section_name].append(condition(a_element))
    return result

def parse_author(author_span):
    result = {}
    a_element = author_span.find('a')
    if a_element:
        text = a_element.get_text().strip()
        name = ' '.join(i for i in text.split() if i)
        result['POET'] = name
    return result

def parse_text(poem_div):
    result = []
    for div in poem_div.find_all(['div', 'br']):
        sentence = div.get_text().rstrip()
        result.append(sentence)

    if not result:
        text = poem_div.get_text().rstrip()
        if text:
            result = [text]

    return result

collection = mongo_collection()
directory = sys.argv[1]
filename_list = os.listdir(directory)
for index, filename in enumerate(filename_list):
    path = os.path.join(directory, filename)
    print(index, len(filename_list), filename, file=sys.stderr)
    with open(path) as infile:
        soup = bs4.BeautifulSoup(infile, 'lxml')
        title = soup.find('div', {'id': 'poem-top'}).find('h1').get_text()
        main_div = soup.find('div', {'id': 'poem'})
        poem_div = main_div.find('div', {'class': 'poem'})
        about_div = main_div.find('div', {'class': 'about'})
        author_span = soup.find('span', {'class': 'author'})
        authordata = parse_author(author_span)
        if not about_div:
            about_div = soup.find('div', {'id': 'about'})
        metadata = parse_about(about_div)
        text = parse_text(poem_div)
        item = {
            '_id': filename,
            'title': title,
            'text': text,
            'html': poem_div.decode(formatter='html'),
        }
        item.update(authordata)
        item.update(metadata)
        collection.save(item)


text:
SYNONYM

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

#### Published in
Sydowia 19: 171 (1966)

#### Original name
Cephalosporium incoloratum Sukapure & Thirum., 1966

### Remarks
null


text:
The purpose of this project is to serve as the backend server for the vite
server. The Vite Server will be responsible for providing an api for frontend
agents, security, and will be in charge persisting data through the provided
api.

## Development

This section contains information relevent to people looking to setup and contribute
to the vite server.

### Setup

This section contains information on setting up and running the project locally

- To set up the project, follow the [local setup guide](LOCAL_SETUP.md)
- To run the porject locally follow the [local execution guide](LOCAL_RUN.md)

### Quality Assurance

This section details information on contributing quality code to the repo

- All code must adhere to the [style guide](https://github.com/theVite/vite_central/blob/master/STYLE.md)
- All code should be unit tested whenever possible. The goal is to have 70% code coverage repo wide. Test examples can be found in the [style guide](https://github.com/theVite/vite_central/blob/master/STYLE.md)
- All code must be submitted to code review by making a PR to the [vite_server repo](https://github.com:theVite/vite_server.git)
- All code must be pass quality assurance passes in order to be merged

## License

You can view the [liscense](LICENSE)


text:
<?xml version="1.0" encoding="UTF-8"?>
<GeocodeResponse>
 <status>OK</status>
 <result>
  <type>route</type>
  <formatted_address>Röthenbach, Weißeritzstraße, 01744 Pretzschendorf, Germany</formatted_address>
  <address_component>
   <long_name>Weißeritzstraße</long_name>
   <short_name>Weißeritzstraße</short_name>
   <type>route</type>
  </address_component>
  <address_component>
   <long_name>Röthenbach</long_name>
   <short_name>Röthenbach</short_name>
   <type>political</type>
   <type>sublocality</type>
   <type>sublocality_level_1</type>
  </address_component>
  <address_component>
   <long_name>Pretzschendorf</long_name>
   <short_name>Pretzschendorf</short_name>
   <type>locality</type>
   <type>political</type>
  </address_component>
  <address_component>
   <long_name>Dresden</long_name>
   <short_name>DD</short_name>
   <type>administrative_area_level_2</type>
   <type>political</type>
  </address_component>
  <address_component>
   <long_name>Sachsen</long_name>
   <short_name>SN</short_name>
   <type>administrative_area_level_1</type>
   <type>political</type>
  </address_component>
  <address_component>
   <long_name>Germany</long_name>
   <short_name>DE</short_name>
   <type>country</type>
   <type>political</type>
  </address_component>
  <address_component>
   <long_name>01744</long_name>
   <short_name>01744</short_name>
   <type>postal_code</type>
  </address_component>
  <geometry>
   <location>
    <lat>50.8568752</lat>
    <lng>13.5749342</lng>
   </location>
   <location_type>GEOMETRIC_CENTER</location_type>
   <viewport>
    <southwest>
     <lat>50.8535692</lat>
     <lng>13.5622705</lng>
    </southwest>
    <northeast>
     <lat>50.8605643</lat>
     <lng>13.5873005</lng>
    </northeast>
   </viewport>
   <bounds>
    <southwest>
     <lat>50.8535692</lat>
     <lng>13.5622705</lng>
    </southwest>
    <northeast>
     <lat>50.8605643</lat>
     <lng>13.5873005</lng>
    </northeast>
   </bounds>
  </geometry>
  <partial_match>true</partial_match>
  <place_id>ChIJVxjotWXoCUcRVamXELAJKK8</place_id>
 </result>
</GeocodeResponse>


text:
#include <folly/Traits.h>

#include <gtest/gtest.h>

using namespace folly;
using namespace std;

struct T1 {}; // old-style IsRelocatable, below
struct T2 {}; // old-style IsRelocatable, below
struct T3 { typedef std::true_type IsRelocatable; };
struct T4 { typedef std::true_type IsTriviallyCopyable; };
struct T5 : T3 {};

struct F1 {};
struct F2 { typedef int IsRelocatable; };
struct F3 : T3 { typedef std::false_type IsRelocatable; };
struct F4 : T1 {};

namespace folly {
  template <> struct IsRelocatable<T1> : std::true_type {};
  template <> FOLLY_ASSUME_RELOCATABLE(T2);
}

TEST(Traits, scalars) {
  EXPECT_TRUE(IsRelocatable<int>::value);
  EXPECT_TRUE(IsRelocatable<bool>::value);
  EXPECT_TRUE(IsRelocatable<double>::value);
  EXPECT_TRUE(IsRelocatable<void*>::value);
}

TEST(Traits, containers) {
  EXPECT_TRUE  (IsRelocatable<vector<F1>>::value);
  EXPECT_FALSE((IsRelocatable<pair<F1, F1>>::value));
  EXPECT_TRUE ((IsRelocatable<pair<T1, T2>>::value));
}

TEST(Traits, original) {
  EXPECT_TRUE(IsRelocatable<T1>::value);
  EXPECT_TRUE(IsRelocatable<T2>::value);
}

TEST(Traits, typedefd) {
  EXPECT_TRUE (IsRelocatable<T3>::value);
  EXPECT_TRUE (IsRelocatable<T5>::value);
  EXPECT_FALSE(IsRelocatable<F2>::value);
  EXPECT_FALSE(IsRelocatable<F3>::value);
}

TEST(Traits, unset) {
  EXPECT_FALSE(IsRelocatable<F1>::value);
  EXPECT_FALSE(IsRelocatable<F4>::value);
}

TEST(Traits, bitprop) {
  EXPECT_TRUE(IsTriviallyCopyable<T4>::value);
  EXPECT_TRUE(IsRelocatable<T4>::value);
}

TEST(Traits, bitAndInit) {
  EXPECT_TRUE (IsTriviallyCopyable<int>::value);
  EXPECT_FALSE(IsTriviallyCopyable<vector<int>>::value);
  EXPECT_TRUE (IsZeroInitializable<int>::value);
  EXPECT_FALSE(IsZeroInitializable<vector<int>>::value);
}

TEST(Traits, is_negative) {
  EXPECT_TRUE(folly::is_negative(-1));
  EXPECT_FALSE(folly::is_negative(0));
  EXPECT_FALSE(folly::is_negative(1));
  EXPECT_FALSE(folly::is_negative(0u));
  EXPECT_FALSE(folly::is_negative(1u));

  EXPECT_TRUE(folly::is_non_positive(-1));
  EXPECT_TRUE(folly::is_non_positive(0));
  EXPECT_FALSE(folly::is_non_positive(1));
  EXPECT_TRUE(folly::is_non_positive(0u));
  EXPECT_FALSE(folly::is_non_positive(1u));
}

TEST(Traits, relational) {
  // We test, especially, the edge cases to make sure we don't
  // trip -Wtautological-comparisons

  EXPECT_FALSE((folly::less_than<uint8_t, 0u,   uint8_t>(0u)));
  EXPECT_FALSE((folly::less_than<uint8_t, 0u,   uint8_t>(254u)));
  EXPECT_FALSE((folly::less_than<uint8_t, 255u, uint8_t>(255u)));
  EXPECT_TRUE( (folly::less_than<uint8_t, 255u, uint8_t>(254u)));

  EXPECT_FALSE((folly::greater_than<uint8_t, 0u,   uint8_t>(0u)));
  EXPECT_TRUE( (folly::greater_than<uint8_t, 0u,   uint8_t>(254u)));
  EXPECT_FALSE((folly::greater_than<uint8_t, 255u, uint8_t>(255u)));
  EXPECT_FALSE((folly::greater_than<uint8_t, 255u, uint8_t>(254u)));
}

struct membership_no {};
struct membership_yes { using x = void; };
FOLLY_CREATE_HAS_MEMBER_TYPE_TRAITS(has_member_type_x, x);

TEST(Traits, has_member_type) {
  EXPECT_FALSE(bool(has_member_type_x<membership_no>::value));
  EXPECT_TRUE(bool(has_member_type_x<membership_yes>::value));
}


text:
#include "play_sd_wav.h"
#include "spi_interrupt.h"

#define STATE_DIRECT_8BIT_MONO		0  // playing mono at native sample rate
#define STATE_DIRECT_8BIT_STEREO	1  // playing stereo at native sample rate
#define STATE_DIRECT_16BIT_MONO		2  // playing mono at native sample rate
#define STATE_DIRECT_16BIT_STEREO	3  // playing stereo at native sample rate
#define STATE_CONVERT_8BIT_MONO		4  // playing mono, converting sample rate
#define STATE_CONVERT_8BIT_STEREO	5  // playing stereo, converting sample rate
#define STATE_CONVERT_16BIT_MONO	6  // playing mono, converting sample rate
#define STATE_CONVERT_16BIT_STEREO	7  // playing stereo, converting sample rate
#define STATE_PARSE1			8  // looking for 20 byte ID header
#define STATE_PARSE2			9  // looking for 16 byte format header
#define STATE_PARSE3			10 // looking for 8 byte data header
#define STATE_PARSE4			11 // ignoring unknown chunk
#define STATE_STOP			12

void AudioPlaySdWav::begin(void)
{
	state = STATE_STOP;
	state_play = STATE_STOP;
	data_length = 0;
	if (block_left) {
		release(block_left);
		block_left = NULL;
	}
	if (block_right) {
		release(block_right);
		block_right = NULL;
	}
}

bool AudioPlaySdWav::play(const char *filename)
{
	stop();
#if defined(HAS_KINETIS_SDHC)
	if (!(SIM_SCGC3 & SIM_SCGC3_SDHC)) AudioStartUsingSPI();
#else
	AudioStartUsingSPI();
#endif
	__disable_irq();
	wavfile = SD.open(filename);
	__enable_irq();
	if (!wavfile) {
	#if defined(HAS_KINETIS_SDHC)
		if (!(SIM_SCGC3 & SIM_SCGC3_SDHC)) AudioStopUsingSPI();
	#else
		AudioStopUsingSPI();
	#endif
		return false;
	}
	buffer_length = 0;
	buffer_offset = 0;
	state_play = STATE_STOP;
	data_length = 20;
	header_offset = 0;
	state = STATE_PARSE1;
	return true;
}

void AudioPlaySdWav::stop(void)
{
	__disable_irq();
	if (state != STATE_STOP) {
		audio_block_t *b1 = block_left;
		block_left = NULL;
		audio_block_t *b2 = block_right;
		block_right = NULL;
		state = STATE_STOP;
		__enable_irq();
		if (b1) release(b1);
		if (b2) release(b2);
		wavfile.close();
	#if defined(HAS_KINETIS_SDHC)
		if (!(SIM_SCGC3 & SIM_SCGC3_SDHC)) AudioStopUsingSPI();
	#else
		AudioStopUsingSPI();
	#endif
	} else {
		__enable_irq();
	}
}

void AudioPlaySdWav::update(void)
{
	int32_t n;

	// only update if we're playing
	if (state == STATE_STOP) return;

	// allocate the audio blocks to transmit
	block_left = allocate();
	if (block_left == NULL) return;
	if (state < 8 && (state & 1) == 1) {
		// if we're playing stereo, allocate another
		// block for the right channel output
		block_right = allocate();
		if (block_right == NULL) {
			release(block_left);
			return;
		}
	} else {
		// if we're playing mono or just parsing
		// the WAV file header, no right-side block
		block_right = NULL;
	}
	block_offset = 0;

	//Serial.println("update");

	// is there buffered data?
	n = buffer_length - buffer_offset;
	if (n > 0) {
		// we have buffered data
		if (consume(n)) return; // it was enough to transmit audio
	}

	// we only get to this point when buffer[512] is empty
	if (state != STATE_STOP && wavfile.available()) {
		// we can read more data from the file...
		readagain:
		buffer_length = wavfile.read(buffer, 512);
		if (buffer_length == 0) goto end;
		buffer_offset = 0;
		bool parsing = (state >= 8);
		bool txok = consume(buffer_length);
		if (txok) {
			if (state != STATE_STOP) return;
		} else {
			if (state != STATE_STOP) {
				if (parsing && state < 8) goto readagain;
				else goto cleanup;
			}
		}
	}
end:	// end of file reached or other reason to stop
	wavfile.close();
#if defined(HAS_KINETIS_SDHC)
	if (!(SIM_SCGC3 & SIM_SCGC3_SDHC)) AudioStopUsingSPI();
#else
	AudioStopUsingSPI();
#endif
	state_play = STATE_STOP;
	state = STATE_STOP;
cleanup:
	if (block_left) {
		if (block_offset > 0) {
			for (uint32_t i=block_offset; i < AUDIO_BLOCK_SAMPLES; i++) {
				block_left->data[i] = 0;
			}
			transmit(block_left, 0);
			if (state < 8 && (state & 1) == 0) {
				transmit(block_left, 1);
			}
		}
		release(block_left);
		block_left = NULL;
	}
	if (block_right) {
		if (block_offset > 0) {
			for (uint32_t i=block_offset; i < AUDIO_BLOCK_SAMPLES; i++) {
				block_right->data[i] = 0;
			}
			transmit(block_right, 1);
		}
		release(block_right);
		block_right = NULL;
	}
}

// https://ccrma.stanford.edu/courses/422/projects/WaveFormat/

// Consume already buffered data.  Returns true if audio transmitted.
bool AudioPlaySdWav::consume(uint32_t size)
{
	uint32_t len;
	uint8_t lsb, msb;
	const uint8_t *p;

	p = buffer + buffer_offset;
start:
	if (size == 0) return false;
#if 0
	Serial.print("AudioPlaySdWav consume, ");
	Serial.print("size = ");
	Serial.print(size);
	Serial.print(", buffer_offset = ");
	Serial.print(buffer_offset);
	Serial.print(", data_length = ");
	Serial.print(data_length);
	Serial.print(", space = ");
	Serial.print((AUDIO_BLOCK_SAMPLES - block_offset) * 2);
	Serial.print(", state = ");
	Serial.println(state);
#endif
	switch (state) {
	  // parse wav file header, is this really a .wav file?
	  case STATE_PARSE1:
		len = data_length;
		if (size < len) len = size;
		memcpy((uint8_t *)header + header_offset, p, len);
		header_offset += len;
		buffer_offset += len;
		data_length -= len;
		if (data_length > 0) return false;
		// parse the header...
		if (header[0] == 0x46464952 && header[2] == 0x45564157
		  && header[3] == 0x20746D66 && header[4] >= 16) {
			if (header[4] > sizeof(header)) {
				// if such .wav files exist, increasing the
				// size of header[] should accomodate them...
				//Serial.println("WAVEFORMATEXTENSIBLE too long");
				break;
			}
			//Serial.println("header ok");
			p += len;
			size -= len;
			data_length = header[4];
			header_offset = 0;
			state = STATE_PARSE2;
			goto start;
		}
		//Serial.println("unknown WAV header");
		break;

	  // check & extract key audio parameters
	  case STATE_PARSE2:
		len = data_length;
		if (size < len) len = size;
		memcpy((uint8_t *)header + header_offset, p, len);
		header_offset += len;
		buffer_offset += len;
		data_length -= len;
		if (data_length > 0) return false;
		if (parse_format()) {
			//Serial.println("audio format ok");
			p += len;
			size -= len;
			data_length = 8;
			header_offset = 0;
			state = STATE_PARSE3;
			goto start;
		}
		//Serial.println("unknown audio format");
		break;

	  // find the data chunk
	  case STATE_PARSE3: // 10
		len = data_length;
		if (size < len) len = size;
		memcpy((uint8_t *)header + header_offset, p, len);
		header_offset += len;
		buffer_offset += len;
		data_length -= len;
		if (data_length > 0) return false;
		//Serial.print("chunk id = ");
		//Serial.print(header[0], HEX);
		//Serial.print(", length = ");
		//Serial.println(header[1]);
		p += len;
		size -= len;
		data_length = header[1];
		if (header[0] == 0x61746164) {
			//Serial.print("wav: found data chunk, len=");
			//Serial.println(data_length);
			// TODO: verify offset in file is an even number
			// as required by WAV format.  abort if odd.  Code
			// below will depend upon this and fail if not even.
			leftover_bytes = 0;
			state = state_play;
			if (state & 1) {
				// if we're going to start stereo
				// better allocate another output block
				block_right = allocate();
				if (!block_right) return false;
			}
			total_length = data_length;
		} else {
			state = STATE_PARSE4;
		}
		goto start;

	  // ignore any extra unknown chunks (title & artist info)
	  case STATE_PARSE4: // 11
		if (size < data_length) {
			data_length -= size;
			buffer_offset += size;
			return false;
		}
		p += data_length;
		size -= data_length;
		buffer_offset += data_length;
		data_length = 8;
		header_offset = 0;
		state = STATE_PARSE3;
		//Serial.println("consumed unknown chunk");
		goto start;

	  // playing mono at native sample rate
	  case STATE_DIRECT_8BIT_MONO:
		return false;

	  // playing stereo at native sample rate
	  case STATE_DIRECT_8BIT_STEREO:
		return false;

	  // playing mono at native sample rate
	  case STATE_DIRECT_16BIT_MONO:
		if (size > data_length) size = data_length;
		data_length -= size;
		while (1) {
			lsb = *p++;
			msb = *p++;
			size -= 2;
			block_left->data[block_offset++] = (msb << 8) | lsb;
			if (block_offset >= AUDIO_BLOCK_SAMPLES) {
				transmit(block_left, 0);
				transmit(block_left, 1);
				release(block_left);
				block_left = NULL;
				data_length += size;
				buffer_offset = p - buffer;
				if (block_right) release(block_right);
				if (data_length == 0) state = STATE_STOP;
				return true;
			}
			if (size == 0) {
				if (data_length == 0) break;
				return false;
			}
		}
		//Serial.println("end of file reached");
		// end of file reached
		if (block_offset > 0) {
			// TODO: fill remainder of last block with zero and transmit
		}
		state = STATE_STOP;
		return false;

	  // playing stereo at native sample rate
	  case STATE_DIRECT_16BIT_STEREO:
		if (size > data_length) size = data_length;
		data_length -= size;
		if (leftover_bytes) {
			block_left->data[block_offset] = header[0];
//PAH fix problem with left+right channels being swapped
			leftover_bytes = 0;
			goto right16;
		}
		while (1) {
			lsb = *p++;
			msb = *p++;
			size -= 2;
			if (size == 0) {
				if (data_length == 0) break;
				header[0] = (msb << 8) | lsb;
				leftover_bytes = 2;
				return false;
			}
			block_left->data[block_offset] = (msb << 8) | lsb;
			right16:
			lsb = *p++;
			msb = *p++;
			size -= 2;
			block_right->data[block_offset++] = (msb << 8) | lsb;
			if (block_offset >= AUDIO_BLOCK_SAMPLES) {
				transmit(block_left, 0);
				release(block_left);
				block_left = NULL;
				transmit(block_right, 1);
				release(block_right);
				block_right = NULL;
				data_length += size;
				buffer_offset = p - buffer;
				if (data_length == 0) state = STATE_STOP;
				return true;
			}
			if (size == 0) {
				if (data_length == 0) break;
				leftover_bytes = 0;
				return false;
			}
		}
		// end of file reached
		if (block_offset > 0) {
			// TODO: fill remainder of last block with zero and transmit
		}
		state = STATE_STOP;
		return false;

	  // playing mono, converting sample rate
	  case STATE_CONVERT_8BIT_MONO :
		return false;

	  // playing stereo, converting sample rate
	  case STATE_CONVERT_8BIT_STEREO:
		return false;

	  // playing mono, converting sample rate
	  case STATE_CONVERT_16BIT_MONO:
		return false;

	  // playing stereo, converting sample rate
	  case STATE_CONVERT_16BIT_STEREO:
		return false;

	  // ignore any extra data after playing
	  // or anything following any error
	  case STATE_STOP:
		return false;

	  // this is not supposed to happen!
	  //default:
		//Serial.println("AudioPlaySdWav, unknown state");
	}
	state_play = STATE_STOP;
	state = STATE_STOP;
	return false;
}

/*
00000000  52494646 66EA6903 57415645 666D7420  RIFFf.i.WAVEfmt
00000010  10000000 01000200 44AC0000 10B10200  ........D.......
00000020  04001000 4C495354 3A000000 494E464F  ....LIST:...INFO
00000030  494E414D 14000000 49205761 6E742054  INAM....I Want T
00000040  6F20436F 6D65204F 76657200 49415254  o Come Over.IART
00000050  12000000 4D656C69 73736120 45746865  ....Melissa Ethe
00000060  72696467 65006461 746100EA 69030100  ridge.data..i...
00000070  FEFF0300 FCFF0400 FDFF0200 0000FEFF  ................
00000080  0300FDFF 0200FFFF 00000100 FEFF0300  ................
00000090  FDFF0300 FDFF0200 FFFF0100 0000FFFF  ................
*/

// SD library on Teensy3 at 96 MHz
//  256 byte chunks, speed is 443272 bytes/sec
//  512 byte chunks, speed is 468023 bytes/sec

#define B2M_44100 (uint32_t)((double)4294967296000.0 / AUDIO_SAMPLE_RATE_EXACT) // 97352592
#define B2M_22050 (uint32_t)((double)4294967296000.0 / AUDIO_SAMPLE_RATE_EXACT * 2.0)
#define B2M_11025 (uint32_t)((double)4294967296000.0 / AUDIO_SAMPLE_RATE_EXACT * 4.0)

bool AudioPlaySdWav::parse_format(void)
{
	uint8_t num = 0;
	uint16_t format;
	uint16_t channels;
	uint32_t rate, b2m;
	uint16_t bits;

	format = header[0];
	//Serial.print("  format = ");
	//Serial.println(format);
	if (format != 1) return false;

	rate = header[1];
	//Serial.print("  rate = ");
	//Serial.println(rate);
	if (rate == 44100) {
		b2m = B2M_44100;
	} else if (rate == 22050) {
		b2m = B2M_22050;
		num |= 4;
	} else if (rate == 11025) {
		b2m = B2M_11025;
		num |= 4;
	} else {
		return false;
	}

	channels = header[0] >> 16;
	//Serial.print("  channels = ");
	//Serial.println(channels);
	if (channels == 1) {
	} else if (channels == 2) {
		b2m >>= 1;
		num |= 1;
	} else {
		return false;
	}

	bits = header[3] >> 16;
	//Serial.print("  bits = ");
	//Serial.println(bits);
	if (bits == 8) {
	} else if (bits == 16) {
		b2m >>= 1;
		num |= 2;
	} else {
		return false;
	}

	bytes2millis = b2m;
	//Serial.print("  bytes2millis = ");
	//Serial.println(b2m);

	// we're not checking the byte rate and block align fields
	// if they're not the expected values, all we could do is
	// return false.  Do any real wav files have unexpected
	// values in these other fields?
	state_play = num;
	return true;
}

bool AudioPlaySdWav::isPlaying(void)
{
	return (state < 8);
}

uint32_t AudioPlaySdWav::positionMillis(void)
{
	if (state >= 8) return 0;
	uint32_t offset = total_length - data_length;
	return ((uint64_t)offset * bytes2millis) >> 32;
}

uint32_t AudioPlaySdWav::lengthMillis(void)
{
	if (state >= 8) return 0;
	return ((uint64_t)total_length * bytes2millis) >> 32;
}


text:
package org.apache.ignite.springdata22.repository.config;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Annotation to provide a user defined query for a method.
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Query {
    /**
     * Query text string. If not provided, Ignite query generator for Spring Data framework will be used to generate one
     * (only if textQuery = false (default))
     */
    String value() default "";

    /**
     * Whether annotated repository method must use TextQuery search.
     */
    boolean textQuery() default false;

    /**
     * Force SqlFieldsQuery type, deactivating auto-detection based on SELECT statement. Useful for non SELECT
     * statements or to not return hidden fields on SELECT * statements.
     */
    boolean forceFieldsQuery() default false;

    /**
     * Sets flag defining if this query is collocated.
     *

     * Collocation flag is used for optimization purposes of queries with GROUP BY statements. Whenever Ignite executes
     * a distributed query, it sends sub-queries to individual cluster members. If you know in advance that the elements
     * of your query selection are collocated together on the same node and you group by collocated key (primary or
     * affinity key), then Ignite can make significant performance and network optimizations by grouping data on remote
     * nodes.
     *
     *

     * Only applicable to SqlFieldsQuery
     */
    boolean collocated() default false;

    /**
     * Query timeout in millis. Sets the query execution timeout. Query will be automatically cancelled if the execution
     * timeout is exceeded. Zero value disables timeout
     *
     *

     * Only applicable to SqlFieldsQuery and SqlQuery
     */
    int timeout() default 0;

    /**
     * Sets flag to enforce join order of tables in the query. If set to {@code true} query optimizer will not reorder
     * tables in join. By default is {@code false}.
     *

     * It is not recommended to enable this property until you are sure that your indexes and the query itself are
     * correct and tuned as much as possible but query optimizer still produces wrong join order.
     *
     *

     * Only applicable to SqlFieldsQuery
     */
    boolean enforceJoinOrder() default false;

    /**
     * Specify if distributed joins are enabled for this query.
     *

     * Only applicable to SqlFieldsQuery and SqlQuery
     */
    boolean distributedJoins() default false;

    /**
     * Sets lazy query execution flag.
     *

     * By default Ignite attempts to fetch the whole query result set to memory and send it to the client. For small and
     * medium result sets this provides optimal performance and minimize duration of internal database locks, thus
     * increasing concurrency.
     *

     * If result set is too big to fit in available memory this could lead to excessive GC pauses and even
     * OutOfMemoryError. Use this flag as a hint for Ignite to fetch result set lazily, thus minimizing memory
     * consumption at the cost of moderate performance hit.
     *

     * Defaults to {@code false}, meaning that the whole result set is fetched to memory eagerly.
     *

     * Only applicable to SqlFieldsQuery
     */
    boolean lazy() default false;

    /**
     * Sets whether this query should be executed on local node only.
     */
    boolean local() default false;

    /**
     * Sets partitions for a query. The query will be executed only on nodes which are primary for specified
     * partitions.
     *

     * Note what passed array'll be sorted in place for performance reasons, if it wasn't sorted yet.
     *

     * Only applicable to SqlFieldsQuery and SqlQuery
     */
    int[] parts() default {};

    /**
     * Specify whether the annotated method must provide a non null {@link DynamicQueryConfig} parameter with a non
     * empty value (query string) or {@link DynamicQueryConfig#textQuery()} == true.
     *

     * Please, note that  {@link DynamicQueryConfig#textQuery()} annotation parameters will be ignored in favor of those
     * defined in {@link DynamicQueryConfig} parameter if present (runtime ignite query tuning).
     */
    boolean dynamicQuery() default false;

    /**
     * Sets limit to response records count for TextQuery. If 0 or less, considered to be no limit.
     */
    int limit() default 0;
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _3FlattenDictionary
{
    class FlattenDictionary
    {
        static void Main(string[] args)
        {
            var dictionary = new Dictionary<string, Dictionary<string, string>>();

            var inputLine = Console.ReadLine();

            while (inputLine != "end")
            {
                var inputParams = inputLine.Split(' ');

                if (inputParams[0] != "flatten")
                {
                    var key = inputParams[0];
                    var innerKey = inputParams[1];
                    var innerValue = inputParams[2];

                    if (!dictionary.ContainsKey(key))
                    {
                        dictionary.Add(key, new Dictionary<string, string>());
                    }

                    dictionary[key][innerKey] = innerValue;

                }
                else
                {
                    var key = inputParams[1];
                    dictionary[key] = dictionary[key]
                        .ToDictionary(x => x.Key + x.Value, x => "flattened");

                }
                inputLine = Console.ReadLine();
            }
            var orderedDictionary = dictionary
                .OrderByDescending(x => x.Key.Length)
                .ToDictionary(x => x.Key, x => x.Value);

            foreach (var entry in orderedDictionary)
            {
                Console.WriteLine("{0}", entry.Key);

                var orderedInnerDictionary =
                    entry.Value
                    .Where(x=>x.Value!="flattened")
                    .OrderBy(x => x.Key.Length)
                    .ToDictionary(x => x.Key, x => x.Value);

                var flattenedValues = entry.Value
                    .Where(x => x.Value == "flattened")
                    .ToDictionary(x => x.Key, x => x.Value);

                var count = 1;
                foreach (var innerEntry in orderedInnerDictionary)
                {
                    Console.WriteLine("{0}. {1} - {2}",count, innerEntry.Key, innerEntry.Value);
                    count++;
                }
                foreach (var flattenedEntry in flattenedValues)
                {
                    Console.WriteLine("{0}. {1}",count, flattenedEntry.Key);
                    count++;
                }
            }

        }
    }
}


text:
namespace csapex
{
class CSAPEX_CORE_EXPORT ErrorState
{
public:
    enum class ErrorLevel
    {
        NONE = 0,
        INFO = 1,
        ERROR = 2,
        WARNING = 3
    };

public:
    void setError(bool e, const std::string& msg = "", ErrorLevel level = ErrorLevel::ERROR);
    void setErrorSilent(bool e, const std::string& msg = "", ErrorLevel level = ErrorLevel::ERROR);

    virtual bool isError() const;
    virtual ErrorLevel errorLevel() const;
    virtual std::string errorMessage() const;

public:
    slim_signal::Signal<void(bool, const std::string& msg, ErrorLevel level)> error_event;

protected:
    ErrorState();
    virtual ~ErrorState();

    virtual void errorEvent(bool error, const std::string& msg, ErrorLevel level);
    virtual void errorChanged(bool error);

private:
    mutable std::recursive_mutex error_mutex_;
    bool error_;
    std::string error_msg_;
    ErrorLevel level_;
};

}  // namespace csapex

#endif  // DISPLAYABLE_H