text:
<Type Name="NSDraggingImageComponent" FullName="MonoMac.AppKit.NSDraggingImageComponent">
  <TypeSignature Language="C#" Value="public class NSDraggingImageComponent : MonoMac.Foundation.NSObject" />
  <TypeSignature Language="ILAsm" Value=".class public auto ansi beforefieldinit NSDraggingImageComponent extends MonoMac.Foundation.NSObject" />
  <AssemblyInfo>
    <AssemblyName>MonoMac</AssemblyName>
    <AssemblyVersion>0.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <Base>
    <BaseTypeName>MonoMac.Foundation.NSObject</BaseTypeName>
  </Base>
  <Interfaces />
  <Attributes>
    <Attribute>
      <AttributeName>MonoMac.Foundation.Register("NSDraggingImageComponent", true)</AttributeName>
    </Attribute>
  </Attributes>
  <Docs>
    To be added.
    <remarks>To be added.</remarks>
  </Docs>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSDraggingImageComponent ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor() cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("init")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters />
      <Docs>
        Default constructor, initializes a new instance of this class.
        <remarks>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSDraggingImageComponent (MonoMac.Foundation.NSCoder coder);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(class MonoMac.Foundation.NSCoder coder) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("initWithCoder:")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="coder" Type="MonoMac.Foundation.NSCoder" />
      </Parameters>
      <Docs>
        <param name="coder">The unarchiver object.</param>
        A constructor that initializes the object from the data stored in the unarchiver object.
        <remarks>This constructor is provided to allow the class to be initialized from an unarchiver (for example, during NIB deserialization).</remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSDraggingImageComponent (MonoMac.Foundation.NSObjectFlag t);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(class MonoMac.Foundation.NSObjectFlag t) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="t" Type="MonoMac.Foundation.NSObjectFlag" />
      </Parameters>
      <Docs>
        <param name="t">Unused sentinel value, pass NSObjectFlag.Empty.</param>
        Constructor to call on derived classes when the derived class has an [Export] constructor.
        <remarks>
          <para>This constructor should be called by derived classes when they are initialized using an [Export] attribute. The argument value is ignore, typically the chaining would look like this:</para>
          <example>

public class MyClass : BaseClass {
    [Export ("initWithFoo:")]
    public MyClass (string foo) : base (NSObjectFlag.Empty)
    {
        ...
    }

          </example>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSDraggingImageComponent (IntPtr handle);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(native int handle) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="handle" Type="System.IntPtr" />
      </Parameters>
      <Docs>
        <param name="handle">Pointer (handle) to the unmanaged object.</param>
        A constructor used when creating managed representations of unmanaged objects;  Called by the runtime.
        <remarks>
          <para>This constructor is invoked by the runtime infrastructure (<see cref="M:MonoMac.ObjCRuntime.GetNSObject (System.IntPtr)" />) to create a new managed representation for a pointer to an unmanaged Objective-C object.    You should not invoke this method directly, instead you should call the GetNSObject method as it will prevent two instances of a managed object to point to the same native object.</para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public NSDraggingImageComponent (string key);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(string key) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("initWithKey:")</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="key" Type="System.String" />
      </Parameters>
      <Docs>
        <param name="key">To be added.</param>
        To be added.
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="ClassHandle">
      <MemberSignature Language="C#" Value="public override IntPtr ClassHandle { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance native int ClassHandle" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.IntPtr</ReturnType>
      </ReturnValue>
      <Docs>
        The handle for this class.
        <value>The pointer to the Objective-C class.</value>
        <remarks>Each MonoMac class mirrors an unmanaged Objective-C class.   This value contains the pointer to the Objective-C class, it is similar to calling objc_getClass with the object name.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Contents">
      <MemberSignature Language="C#" Value="public virtual MonoMac.Foundation.NSObject Contents { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class MonoMac.Foundation.NSObject Contents" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>get: MonoMac.Foundation.Export("contents")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>set: MonoMac.Foundation.Export("setContents:")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>MonoMac.Foundation.NSObject</ReturnType>
      </ReturnValue>
      <Docs>
        To be added.
        <value>To be added.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Dispose">
      <MemberSignature Language="C#" Value="protected override void Dispose (bool disposing);" />
      <MemberSignature Language="ILAsm" Value=".method familyhidebysig virtual instance void Dispose(bool disposing) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="disposing" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="disposing">
          <para>If set to <see langword="true" />, the method is invoked directly and will dispose manage and unmanaged resources;   If set to <see langword="false" /> the method is being called by the garbage collector finalizer and should only release unmanaged resources.</para>
        </param>
        Releases the resources used by the NSDraggingImageComponent object.
        <remarks>
          <para>This Dispose method releases the resources used by the NSDraggingImageComponent class.</para>
          <para>This method is called by both the Dispose() method and the object finalizer (Finalize).    When invoked by the Dispose method, the parameter disposting <paramref name="disposing" /> is set to <see langword="true" /> and any managed object references that this object holds are also disposed or released;  when invoked by the object finalizer, on the finalizer thread the value is set to <see langword="false" />. </para>
          <para>Calling the Dispose method when you are finished using the NSDraggingImageComponent ensures that all external resources used by this managed object are released as soon as possible.  Once you have invoked the Dispose method, the object is no longer useful and you should no longer make any calls to it.</para>
          <para>  For more information on how to override this method and on the Dispose/IDisposable pattern, read the ``Implementing a Dispose Method'' document at http://msdn.microsoft.com/en-us/library/fs2xkftw.aspx</para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Frame">
      <MemberSignature Language="C#" Value="public virtual System.Drawing.RectangleF Frame { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance valuetype System.Drawing.RectangleF Frame" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>get: MonoMac.Foundation.Export("frame")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>set: MonoMac.Foundation.Export("setFrame:")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Drawing.RectangleF</ReturnType>
      </ReturnValue>
      <Docs>
        To be added.
        <value>To be added.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="FromKey">
      <MemberSignature Language="C#" Value="public static MonoMac.AppKit.NSDraggingImageComponent FromKey (string key);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig class MonoMac.AppKit.NSDraggingImageComponent FromKey(string key) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>MonoMac.Foundation.Export("draggingImageComponentWithKey:")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>MonoMac.AppKit.NSDraggingImageComponent</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="key" Type="System.String" />
      </Parameters>
      <Docs>
        <param name="key">To be added.</param>
        To be added.
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="IconKey">
      <MemberSignature Language="C#" Value="public static MonoMac.Foundation.NSString IconKey { get; }" />
      <MemberSignature Language="ILAsm" Value=".property class MonoMac.Foundation.NSString IconKey" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>MonoMac.Foundation.NSString</ReturnType>
      </ReturnValue>
      <Docs>
        Represents the value associated with the constant NSDraggingImageComponentIconKey
        <value>
        </value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Key">
      <MemberSignature Language="C#" Value="public virtual string Key { get; set; }" />
      <MemberSignature Language="ILAsm" Value=".property instance string Key" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>get: MonoMac.Foundation.Export("key")</AttributeName>
        </Attribute>
        <Attribute>
          <AttributeName>set: MonoMac.Foundation.Export("setKey:")</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Docs>
        To be added.
        <value>To be added.</value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="LabelKey">
      <MemberSignature Language="C#" Value="public static MonoMac.Foundation.NSString LabelKey { get; }" />
      <MemberSignature Language="ILAsm" Value=".property class MonoMac.Foundation.NSString LabelKey" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>0.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>MonoMac.Foundation.NSString</ReturnType>
      </ReturnValue>
      <Docs>
        Represents the value associated with the constant NSDraggingImageComponentLabelKey
        <value>
        </value>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
  </Members>
</Type>


text:
package com.sksamuel.scrimage.nio;

import com.sksamuel.scrimage.ImageParseException;
import com.sksamuel.scrimage.ImmutableImage;

import java.awt.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

/**
 * Utilities for reading of an Image to an array of bytes in a specified format.
 */
public class ImageReaders {

   private static final List<ImageReader> defaultReaders = detectReaders();

   private static List<ImageReader> detectReaders() {
      return detectReaders(Thread.currentThread().getContextClassLoader());
   }

   private static List<ImageReader> detectReaders(ClassLoader classloader) {
      return StreamSupport.stream(ServiceLoader.load(ImageReader.class, classloader).spliterator(), false).collect(Collectors.toList());
   }

   public static ImmutableImage read(ImageSource source, Rectangle rectangle) throws IOException {
      return read(source, rectangle, defaultReaders);
   }

   public static ImmutableImage read(ImageSource source, Rectangle rectangle, ClassLoader classloader) throws IOException {
      return read(source, rectangle, classloader == null ? defaultReaders : detectReaders(classloader));
   }

   /**
    * Attempts to read an image from the given source, using the supplied image readers.
    *
    * @param source the image source
    * @param rectangle an optional subset of the image to read.
    * @param readers the readers that should be used to attempt to load this image.
    */
   public static ImmutableImage read(ImageSource source, Rectangle rectangle, List<ImageReader> readers) throws IOException {
      List<Throwable> errors = new ArrayList<>();
      for (ImageReader reader : readers) {
         try {
            ImmutableImage image = reader.read(source.read(), rectangle);
            if (image == null) {
               errors.add(new IOException(reader + " failed"));
            } else {
               return image;
            }
         } catch (Exception e) {
            errors.add(new IOException(reader.toString() + " failed due to " + e.getMessage(), e));
         }
      }
      if (errors.isEmpty())
         throw new ImageParseException();
      else
         throw new ImageParseException(errors);
   }
}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

	<link href="js/bootstrap.min.css" rel="stylesheet"type="text/css">
	<link href="css/moncss.css" rel="stylesheet"type="text/css">

	<title>Comparison of image viewers - Supported operating systems</title>
	<meta charset="utf-8">

Comparison of image viewers - Supported operating systems

			<fieldset>

					<form action="" method="post">
						<legend style="color:red;font-weight: bold;font-style:italic;text-align: center;" >Formulaire</legend>

								Mac OS :

 <input type="radio" name="FeatureMac OS" value="oui">Yes <input type="radio" name="FeatureMac OS" value = "non">No <input type="radio" name="FeatureMac OS" value = "non">Partial

								Linux :

 <input type="radio" name="FeatureLinux" value="oui">Yes <input type="radio" name="FeatureLinux" value = "non">No <input type="radio" name="FeatureLinux" value = "non">Partial

								Name :
 <input id="0" type="text" name="Feature">

								Windows :

 <input type="radio" name="FeatureWindows" value="oui">Yes <input type="radio" name="FeatureWindows" value = "non">No <input type="radio" name="FeatureWindows" value = "non">Partial

								Last release :
 <input id="1" type="text" name="Feature">

<input type="submit" class="btn btn-info" value="Ajouter un produit" />
					</form>

			</fieldset>


text:
package ua.com.fielden.platform.reflection.testclasses;

import ua.com.fielden.platform.reflection.testannotation.BaseClassAnnotation;
import ua.com.fielden.platform.reflection.testannotation.MethodInBaseClassAnnotation;

@BaseClassAnnotation
public class BaseClass {

    @MethodInBaseClassAnnotation
    public void baseMethod() {

    }
}


text:
#include <aws/elasticloadbalancingv2/model/CreateRuleRequest.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>

using namespace Aws::ElasticLoadBalancingv2::Model;
using namespace Aws::Utils;

CreateRuleRequest::CreateRuleRequest() :
    m_listenerArnHasBeenSet(false),
    m_conditionsHasBeenSet(false),
    m_priority(0),
    m_priorityHasBeenSet(false),
    m_actionsHasBeenSet(false),
    m_tagsHasBeenSet(false)
{
}

Aws::String CreateRuleRequest::SerializePayload() const
{
  Aws::StringStream ss;
  ss << "Action=CreateRule&";
  if(m_listenerArnHasBeenSet)
  {
    ss << "ListenerArn=" << StringUtils::URLEncode(m_listenerArn.c_str()) << "&";
  }

  if(m_conditionsHasBeenSet)
  {
    unsigned conditionsCount = 1;
    for(auto& item : m_conditions)
    {
      item.OutputToStream(ss, "Conditions.member.", conditionsCount, "");
      conditionsCount++;
    }
  }

  if(m_priorityHasBeenSet)
  {
    ss << "Priority=" << m_priority << "&";
  }

  if(m_actionsHasBeenSet)
  {
    unsigned actionsCount = 1;
    for(auto& item : m_actions)
    {
      item.OutputToStream(ss, "Actions.member.", actionsCount, "");
      actionsCount++;
    }
  }

  if(m_tagsHasBeenSet)
  {
    unsigned tagsCount = 1;
    for(auto& item : m_tags)
    {
      item.OutputToStream(ss, "Tags.member.", tagsCount, "");
      tagsCount++;
    }
  }

  ss << "Version=2015-12-01";
  return ss.str();
}

void  CreateRuleRequest::DumpBodyToUrl(Aws::Http::URI& uri ) const
{
  uri.SetQueryString(SerializePayload());
}


text:
<?php
namespace Blog\BlogBundle\Fonctions;

public function debug($data){
	echo '<pre>';
	\Doctrine\Common\Util\Debug::dump($data, $recurciveLevelToDisplay);
	echo '</pre>';
}


text:
ngrok [![Build Status](https://travis-ci.org/bubenshchykov/ngrok.png?branch=master)](https://travis-ci.org/bubenshchykov/ngrok)
=====

![alt ngrok.com](https://ngrok.com/static/img/overview.png)

Ngrok exposes your localhost to the web. https://ngrok.com/

usage
===

[![NPM](https://nodei.co/npm/ngrok.png?global=true&&downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/ngrok/)

It will download the ngrok 2.0 binary for your platform and put it into the bin folder. You can also install ngrok globally and use it directly from bash
```shell
$ npm install ngrok -g
$ ngrok http 8080
```

## authtoken
*Attention, authtoken is required now because of tricky ngrok [bug #27](https://github.com/bubenshchykov/ngrok/issues/27).* Please go to ngrok 2.0 dashboard to obtain an authtoken. The one for ngrok 1.0 won't work. Many advanced features of the ngrok.com service require an authtoken, so it's a good thing anyway. As alternative, use module version 0.1.99 which uses ngrok 1.0 and doesn't require an authtoken.

You can pass it as option with each ```connect``` or set it once for further tunnels
```javascript
ngrok.authtoken(token, function(err, token) {});
```

## connect
```javascript
var ngrok = require('ngrok');

ngrok.connect(function (err, url) {}); // https://757c1652.ngrok.io -> http://localhost:80
ngrok.connect(9090, function (err, url) {}); // https://757c1652.ngrok.io -> http://localhost:9090
ngrok.connect({proto: 'tcp', addr: 22}, function (err, url) {}); // tcp://0.tcp.ngrok.io:48590
ngrok.connect(opts, function(err, url) {});
```
First connect spawns the ngrok process so each next tunnel is created much faster.

## options
```javascript
ngrok.connect({
	proto: 'http', // http|tcp|tls
	addr: 8080, // port or network address
	auth: 'user:pwd', // http basic authentication for tunnel
	subdomain: 'alex', // reserved tunnel name https://alex.ngrok.io,
	authtoken: '12345' // your authtoken from ngrok.com
}, function (err, url) {});
```

Other options: `name, inspect, host_header, bind_tls, hostname, crt, key, client_cas, remote_addr` - read [here](https://ngrok.com/docs)

## disconnect
The ngrok and all tunnels will be killed when node process is done. To stop the tunnels use
```javascript
ngrok.disconnect(url); // stops one
ngrok.disconnect(); // stops all
ngrok.kill(); // kills ngrok process
```

## emitter
Also you can use ngrok as an event emitter, it fires "connect", "disconnect" and "error" events
```javascript
ngrok.once('connect', function (url) {};
ngrok.connect(port);
```

## configs
You can use ngrok's [configurations files](https://ngrok.com/docs#config), then just pass `name` option when making a tunnel
```
OS X	/Users/example/.ngrok2/ngrok.yml
Linux	/home/example/.ngrok2/ngrok.yml
Windows	C:\Users\example\.ngrok2\ngrok.yml
```

## inspector
When tunnel is established you can use the ngrok interface http://127.0.0.1:4040 to inspect the webhooks done via ngrok.


text:
title: IT lesson 15
layout: post
author: felix.warry
permalink: /it-lesson-15/
source-id: 1qFYjRP1RgSjsqUMr5bepVuiLOvssNEY8pCPgQs1Xlvo
published: true
---

    Title
    IT lesson 15
    Date
    20/06/17

    Starting point:
    To continue to progress into learning python using github.

    Target for this lesson?
    To continue to progress into learning python using github.

    Did I reach my target?
(add details to "Lesson Review")
     Yes.

    Lesson Review

    How did I learn? What strategies were effective?

    I learnt no differently than how I did last lesson. I read the text,understood it,then read the instructions and completed the exercise.

    What limited my learning? Which habits do I need to work on?

    My learning was only limited by speed of work and speed of understanding the text.

    What will I change for next time? How will I improve my learning?

    I will work on my speed of work and speed of understanding the text.


text:
// Copyright(C) David W. Jeske, 2014
// Released to the public domain.

using System;
using System.Collections.Generic;

using OpenTK;
using OpenTK.Graphics.OpenGL;

using Util.IcoSphere;

namespace SimpleScene
{
    public class SSMesh_SphereICO : SSIndexedMesh<SSVertex_PosNormTexDiff>
	{
		MeshGeometry3D geom;

		public SSMesh_SphereICO (int divisions, SSTexture texture)
            : base(BufferUsageHint.StaticDraw, BufferUsageHint.StaticDraw)
		{
			this.textureMaterial = new SSTextureMaterial(texture);
			this._Create(divisions);
		}

		private void _computeEquirectangularUVForSpherePoint(Vector3 p, out float u, out float v) {
			// http://paulbourke.net/geometry/transformationprojection/

			// this is the unit surface normal (and surface point)
			Vector3 vpn = p.Normalized();

			// compute latitute and longitute values from the vector to the normalized sphere surface position
			// using Y-up coordinates

			// compute azimuth (x texture coord)
			float longitude = (float) Math.Atan2(vpn.X,vpn.Z);       // azimuth [-PI  to PI]
			u = (float) (( longitude / (2.0 * Math.PI) ) + 0.5);     // [0 to 1]

			// compute altitude (y texture coord)
			float latitude = (float) Math.Acos(vpn.Y);               // altitude [0 to PI]
			v = (float) (latitude / Math.PI);                        // [0 to 1]

			// v = (float) ( Math.Log((1.0 + Math.Sin(latitude))/(1.0 - Math.Sin(latitude))) / (4.0 * Math.PI) );
		}

		private void _Create(int divisions) {
			var icoSphereCreator = new IcoSphereCreator();
			geom = icoSphereCreator.Create(divisions);
			var positions = geom.Positions.ToArray();

			var vertexSoup = new SimpleScene.Util3d.VertexSoup<SSVertex_PosNormTexDiff>();
			var indexList = new List<UInt16>();

			// we have to process each face in the IcoSphere, so we can
			// properly "wrap" the texture-coordinates that fall across the left/right border
			foreach (TriangleIndices face in geom.Faces) {
				var vp1 = positions[face.v1];
				var vp2 = positions[face.v2];
				var vp3 = positions[face.v3];

				var normal1 = vp1.Normalized();
				var normal2 = vp2.Normalized();
				var normal3 = vp3.Normalized();

				float s1,s2,s3,t1,t2,t3;

			    _computeEquirectangularUVForSpherePoint(normal1,out s1, out t1);
				_computeEquirectangularUVForSpherePoint(normal2,out s2, out t2);
				_computeEquirectangularUVForSpherePoint(normal3,out s3, out t3);

				// configure verticies

				var v1 = new SSVertex_PosNormTexDiff();
				v1.Position = vp1;
				v1.Normal = normal1;
				v1.Tu = s1;
				v1.Tv = t1;

				var v2 = new SSVertex_PosNormTexDiff();
				v2.Position = vp2;
				v2.Normal = normal2;
				v2.Tu = s2;
				v2.Tv = t2;

				var v3 = new SSVertex_PosNormTexDiff();
				v3.Position = vp3;
				v3.Normal = normal3;
				v3.Tu = s3;
				v3.Tv = t3;

				// if a triangle spans the left/right seam where U transitions from 1 to -1
				bool v1_left = vp1.X < 0.0f;
				bool v2_left = vp2.X < 0.0f;
				bool v3_left = vp3.X < 0.0f;
				if (vp1.Z < 0.0f && vp2.Z < 0.0f && vp3.Z < 0.0f &&
                    ((v2_left != v1_left) || (v3_left != v1_left))) {
					// we need to "wrap" texture coordinates
					if (v1.Tu < 0.5f) { v1.Tu += 1.0f; }
					if (v2.Tu < 0.5f) { v2.Tu += 1.0f; }
					if (v3.Tu < 0.5f) { v3.Tu += 1.0f; }
				}

				// add configured verticies to mesh..

				UInt16 idx1 = vertexSoup.digestVertex(ref v1);
				UInt16 idx2 = vertexSoup.digestVertex(ref v2);
				UInt16 idx3 = vertexSoup.digestVertex(ref v3);

				indexList.Add(idx1);
				indexList.Add(idx2);
				indexList.Add(idx3);
			}

            updateVertices(vertexSoup.verticies.ToArray());
            updateIndices(indexList.ToArray());

		}

		public override float boundingSphereRadius {
			get {
				float radSq = 0f;
				foreach (var point in geom.Positions) {
					radSq = Math.Max (radSq, point.LengthSquared);
				}
				return (float)Math.Sqrt (radSq);
			}
		}

		public override Vector3 boundingSphereCenter {
			get { return Vector3.Zero; }
		}
	}
}


text:
/*
 * Author: doe300
 *
 * See the file "LICENSE" for the full license governing this code.
 */

#ifndef COMBINER_H
#define COMBINER_H

#include "../helper.h"
#include "../performance.h"

#include <functional>
#include <vector>

namespace vc4c
{
    class Method;
    class Module;
    class InstructionWalker;
    struct Configuration;
    class Local;
    struct Register;

    namespace intermediate
    {
        struct MoveOperation;
        struct Operation;
        class IntermediateInstruction;
    } // namespace intermediate

    namespace optimizations
    {
        /*
         * Combine successive branches to the same label into a single branch.
         * Also eliminates branches to the label directly following the branch and replaces them with automatic
         * fall-through.
         *
         * Example:
         *   label: %91
         *   br %103
         *   label: %92
         *   br %103
         *   label: %93
         *   br %103
         *   label: %94
         *   br %103
         *   label: %95
         *   br %103
         *   [...]
         *   br %105
         *   label %105
         *
         * is converted into:
         *   label: %91
         *   label: %92
         *   label: %93
         *   label: %94
         *   label: %95
         *   br %103
         *   [...]
         *   label %105
         */
        std::size_t simplifyBranches(const Module& module, Method& method, const Configuration& config);

        /**
         * Additional data to influence the merge condition checking and relay intermediate information between the
         * single conditions
         */
        struct MergeConditionData
        {
            /**
             * The optional label-to-register map. If this is set, the merge conditions are checked in "peephole mode",
             * modifying some checks from a more generic version to check the exact registers locals are mapped to,
             * allowing for more accurate results.
             *
             * This value has to be set before the merge condition checks are started.
             */
            const FastMap<const Local*, Register>* registerMap = nullptr;
            /**
             * One of the instructions is a simple move of zero and can be rewritten by converting to an xor of the one
             * of the (literal) inputs of the other instruction.
             *
             * This value is set during the merge condition checks.
             */
            intermediate::MoveOperation* rewriteSimpleMoveOfZero = nullptr;

            bool isPeepholeRun() const noexcept;
        };

        using MergeCondition = FunctionPointer<bool(intermediate::Operation*, intermediate::Operation*,
            intermediate::MoveOperation*, intermediate::MoveOperation*, MergeConditionData&)>;

        // The global merge conditions
        extern const std::vector<MergeCondition> MERGE_CONDITIONS;

        /**
         * Utility function to do the actual combination of operations
         *
         * On success, the CombinedInstruction is inserted into the first parameter it while the second parameter nextIt
         * is erased, making it inaccessible for further processing.
         *
         * NOTE: This function does NOT check for combinability, this has to be done before!
         */
        bool combineOperationsInner(InstructionWalker it, InstructionWalker nextIt);

        /*
         * Combine ALU-instructions which (can) use different ALUs into a single instruction accessing both ALUs.
         * There are two types of instruction-pairs which can be combined:
         * - The instructions do not depend on one another, their relative order unimportant (e.g. output of first
         * instruction is not read in second one)
         * - Both instructions write to the same output but with inverted conditions (see example)
         *
         * Example (source taken from #combineSelectionWithZero):
         *   %5 = %11 (ifz)
         *   %5 = xor %11, %11 (ifzc)
         *
         * is converted to:
         *   %5 = xor %11, %11 (ifzc) and %5 = v8min %11, %11 (ifz)
         *
         * NOTE: As of this point, the instruction-type CombinedInstruction can occur within a basic block!
         * Also, only moves and ALU instructions are combined at the moment
         */
        std::size_t combineOperations(const Module& module, Method& method, const Configuration& config);

        /*
         * Combines the loading of the same constant value (e.g. literal or constant register) within a small range in a
         * single basic block
         *
         * Example:
         *   %3 = loadi 123456
         *   ...
         *   %7 = loadi 123456
         *   %8 = mul24 %3, %4
         *   %9 = add %7, %5
         *
         * is converted to:
         *   %3 = loadi 123456
         *   ...
         *   %8 = mul24 %3, %4
         *   %9 = add %3, %5
         *
         * Also:
         *   %5 = qpu_num
         *   %6 = add %5, %4
         *   ...
         *   %7 = qpu_num
         *   %8 = and %7, %6
         *
         * is converted to:
         *   %5 = qpu_num
         *   %6 = add %5, %4
         *   ...
         *   %8 = and %5, %6
         */
        std::size_t combineLoadingConstants(const Module& module, Method& method, const Configuration& config);
        /**
         * Same as above, but uses the given set of "white-listed" instructions instead of checking for a limited
         * usage-range
         */
        std::size_t combineLoadingConstants(Method& method, const Configuration& config,
            const FastSet<const intermediate::IntermediateInstruction*>& applicableInstructions);

        /*
         * Prepares selections (successive writes to same value with inverted conditions) which write to a local, have
         * no side-effects and one of the sources is zero for combination, by rewriting the zero-write to xor-ing the
         * other value
         *
         * Example:
         *   %5 = %11 (ifz)
         *   %5 = 0 (ifzc)
         *
         * is converted to:
         *   %5 = %11 (ifz)
         *   %5 = xor %11, %11 (ifzc)
         */
        InstructionWalker combineSelectionWithZero(
            const Module& module, Method& method, InstructionWalker it, const Configuration& config);

        /*
         * Combines vector several consecutive rotations with the same data
         *
         * Example:
         *   %4 = %3 << 2
         *   %5 = %4 << 6
         *
         * is converted to:
         *   %5 = %3 << 8
         *
         * NOTE: This optimization currently only works for constant rotation offsets.
         */
        std::size_t combineVectorRotations(const Module& module, Method& method, const Configuration& config);

        /*
         * Combines arithmetic operations if the result of the first operation is used as the second operation and the
         * operations allow combining (e.g. no side-effects).
         *
         * Also, the combining is only done if an instruction can be saved (e.g. intermediate result has single usage)
         *
         * Example:
         *   %a = add %b, 3
         *   [...]
         *   %c = add %a, 4
         *
         * becomes:
         *   %c = add %b, 7
         *
         * Also:
         *   %a = shl %b, 4
         *   [...]
         *   %c = shl %a, 3
         *
         * becomes:
         *   %c = shl %b, 7
         *
         */
        InstructionWalker combineArithmeticOperations(
            const Module& module, Method& method, InstructionWalker it, const Configuration& config);
    } // namespace optimizations
} // namespace vc4c
#endif /* COMBINER_H */


text:
try:
  from setuptools import setup
  from setuptools.extension import Extension
except Exception:
  from distutils.core import setup
  from distutils.extension import Extension

from modules.helpers import env_or_default

from Cython.Build import cythonize
from Cython.Distutils import build_ext
import numpy
import mpi4py

_extra = [
  '-fopenmp' ,
  '-lmpi',
  '-ldl',
  '-lhwloc',
  '-O3',
  '-ffast-math'
]

install_requires = [
  'numpy==1.8.2',
  'cython>=0.20.0',
  'mpi4py==1.3.1'
]

include_dirs = env_or_default(
  'MPI_INCLUDES',
  '/usr/lib/openmpi/include;/usr/lib/openmpi/include/openmpi'
).split(';') + [
  numpy.get_include(),
  mpi4py.get_include()
]

_extra_link_args = [
  '-fopenmp',
  '-lmpi'
]

print(include_dirs)

extensions = [
  Extension('segments',
            sources = ['./src/segments.pyx'],
            extra_compile_args = _extra,
            extra_link_args = _extra_link_args
  ),
  Extension('differentialLine',
            sources = ['./src/differentialLine.pyx'],
            extra_compile_args = _extra,
            extra_link_args = _extra_link_args
  )
]

setup(
  name = "differential-line",
  version = '0.0.4',
  author = '@inconvergent',
  install_requires = install_requires,
  license = 'MIT',
  cmdclass={'build_ext' : build_ext},
  include_dirs = include_dirs,
  ext_modules = cythonize(
    extensions,
    include_path = include_dirs
  )
)


text:
package ch.hearc.pokerface.gameengine.gamecore;

public enum Action
{
	Bet("bets"), Raise("raises"), Fold("folds"), Call("calls"), Check("checks"), Allin("all in with"), PostSmallBlind("posts small blind"), PostBigBlind("posts big blind"), Winner("Winner"), Loser("Loser"), WinMoney("wins"), YourTurn("yourturn"), Leave("sits out");

	/*------------------------------------------------------------------*\
	|*							Attributs Private						*|
	\*------------------------------------------------------------------*/

	private String	valueString;

	/*------------------------------------------------------------------*\
	|*							Constructeurs							*|
	\*------------------------------------------------------------------*/

	private Action(String valString)
	{
		valueString = valString;
	}

	/*------------------------------------------------------------------*\
	|*							Methodes Public							*|
	\*------------------------------------------------------------------*/

	@Override
	public String toString()
	{
		return valueString;
	}
}


text:
\hypertarget{classtheoria_1_1core_1_1AppConfigResolverComp}{}\section{theoria\+:\+:core\+:\+:App\+Config\+Resolver\+Comp Class Reference}
\label{classtheoria_1_1core_1_1AppConfigResolverComp}\index{theoria\+::core\+::\+App\+Config\+Resolver\+Comp@{theoria\+::core\+::\+App\+Config\+Resolver\+Comp}}

{\ttfamily \#include $<$Core\+Components.\+h$>$}

Inheritance diagram for theoria\+:\+:core\+:\+:App\+Config\+Resolver\+Comp\+:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=207pt]{classtheoria_1_1core_1_1AppConfigResolverComp__inherit__graph}
\end{center}
\end{figure}

Collaboration diagram for theoria\+:\+:core\+:\+:App\+Config\+Resolver\+Comp\+:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=350pt]{classtheoria_1_1core_1_1AppConfigResolverComp__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Member Functions}
\begin{DoxyCompactItemize}
\item
\hyperlink{classtheoria_1_1core_1_1AppConfigResolverComp_a49f449b95efaa632d5398b161b28144e}{App\+Config\+Resolver\+Comp} (Comp\+Id \hyperlink{classtheoria_1_1core_1_1Component_ab539df9f996efceda7743fa1b69cd25d}{id})
\item
\hyperlink{classtheoria_1_1core_1_1Component}{Component} $\ast$ \hyperlink{classtheoria_1_1core_1_1AppConfigResolverComp_af04af67f66e3bfea44ab76c33d64a51e}{acquire} (const std\+::type\+\_\+info \&type\+Info, void $\ast$$\ast$dest) override
\end{DoxyCompactItemize}
\subsection*{Static Public Member Functions}
\begin{DoxyCompactItemize}
\item
static \hyperlink{classtheoria_1_1core_1_1Component}{Component} $\ast$ \hyperlink{classtheoria_1_1core_1_1AppConfigResolverComp_aa439f83c466b28a3d1df82cc106f87b4}{factory} (Comp\+Id \hyperlink{classtheoria_1_1core_1_1Component_ab539df9f996efceda7743fa1b69cd25d}{id})
\end{DoxyCompactItemize}
\subsection*{Static Public Attributes}
\begin{DoxyCompactItemize}
\item
static D\+L\+L\+\_\+\+P\+U\+B\+L\+IC \hyperlink{classtheoria_1_1core_1_1RegisterThis}{Register\+This}$<$ \hyperlink{classtheoria_1_1core_1_1AppConfigResolverComp}{App\+Config\+Resolver\+Comp} $>$ \hyperlink{classtheoria_1_1core_1_1AppConfigResolverComp_a25d3ff11e2e50221cd2755fbc8feb313}{rt}
\end{DoxyCompactItemize}
\subsection*{Additional Inherited Members}

\subsection{Detailed Description}
\hyperlink{classtheoria_1_1core_1_1Component}{Component} wrapper to a \hyperlink{classtheoria_1_1core_1_1AppConfigResolver}{App\+Config\+Resolver}

\subsection{Constructor \& Destructor Documentation}
\mbox{\Hypertarget{classtheoria_1_1core_1_1AppConfigResolverComp_a49f449b95efaa632d5398b161b28144e}\label{classtheoria_1_1core_1_1AppConfigResolverComp_a49f449b95efaa632d5398b161b28144e}}
\index{theoria\+::core\+::\+App\+Config\+Resolver\+Comp@{theoria\+::core\+::\+App\+Config\+Resolver\+Comp}!App\+Config\+Resolver\+Comp@{App\+Config\+Resolver\+Comp}}
\index{App\+Config\+Resolver\+Comp@{App\+Config\+Resolver\+Comp}!theoria\+::core\+::\+App\+Config\+Resolver\+Comp@{theoria\+::core\+::\+App\+Config\+Resolver\+Comp}}
\subsubsection{\texorpdfstring{App\+Config\+Resolver\+Comp()}{AppConfigResolverComp()}}
{\footnotesize\ttfamily theoria\+::core\+::\+App\+Config\+Resolver\+Comp\+::\+App\+Config\+Resolver\+Comp (\begin{DoxyParamCaption}\item[{Comp\+Id}]{id }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [inline]}}

\hyperlink{classtheoria_1_1core_1_1Component}{Component} constructor

\subsection{Member Function Documentation}
\mbox{\Hypertarget{classtheoria_1_1core_1_1AppConfigResolverComp_af04af67f66e3bfea44ab76c33d64a51e}\label{classtheoria_1_1core_1_1AppConfigResolverComp_af04af67f66e3bfea44ab76c33d64a51e}}
\index{theoria\+::core\+::\+App\+Config\+Resolver\+Comp@{theoria\+::core\+::\+App\+Config\+Resolver\+Comp}!acquire@{acquire}}
\index{acquire@{acquire}!theoria\+::core\+::\+App\+Config\+Resolver\+Comp@{theoria\+::core\+::\+App\+Config\+Resolver\+Comp}}
\subsubsection{\texorpdfstring{acquire()}{acquire()}}
{\footnotesize\ttfamily \hyperlink{classtheoria_1_1core_1_1Component}{Component} $\ast$ App\+Config\+Resolver\+Comp\+::acquire (\begin{DoxyParamCaption}\item[{const std\+::type\+\_\+info \&}]{type\+Info,  }\item[{void $\ast$$\ast$}]{dest }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [override]}, {\ttfamily [virtual]}}

Used to acquire underlying resolver

Reimplemented from \hyperlink{classtheoria_1_1core_1_1Component_a18744abc83e088af3c3d42e0a22c35e3}{theoria\+::core\+::\+Component}.

\mbox{\Hypertarget{classtheoria_1_1core_1_1AppConfigResolverComp_aa439f83c466b28a3d1df82cc106f87b4}\label{classtheoria_1_1core_1_1AppConfigResolverComp_aa439f83c466b28a3d1df82cc106f87b4}}
\index{theoria\+::core\+::\+App\+Config\+Resolver\+Comp@{theoria\+::core\+::\+App\+Config\+Resolver\+Comp}!factory@{factory}}
\index{factory@{factory}!theoria\+::core\+::\+App\+Config\+Resolver\+Comp@{theoria\+::core\+::\+App\+Config\+Resolver\+Comp}}
\subsubsection{\texorpdfstring{factory()}{factory()}}
{\footnotesize\ttfamily \hyperlink{classtheoria_1_1core_1_1Component}{Component} $\ast$ App\+Config\+Resolver\+Comp\+::factory (\begin{DoxyParamCaption}\item[{Comp\+Id}]{id }\end{DoxyParamCaption})\hspace{0.3cm}{\ttfamily [static]}}

Factory for this component

\subsection{Member Data Documentation}
\mbox{\Hypertarget{classtheoria_1_1core_1_1AppConfigResolverComp_a25d3ff11e2e50221cd2755fbc8feb313}\label{classtheoria_1_1core_1_1AppConfigResolverComp_a25d3ff11e2e50221cd2755fbc8feb313}}
\index{theoria\+::core\+::\+App\+Config\+Resolver\+Comp@{theoria\+::core\+::\+App\+Config\+Resolver\+Comp}!rt@{rt}}
\index{rt@{rt}!theoria\+::core\+::\+App\+Config\+Resolver\+Comp@{theoria\+::core\+::\+App\+Config\+Resolver\+Comp}}
\subsubsection{\texorpdfstring{rt}{rt}}
{\footnotesize\ttfamily \hyperlink{classtheoria_1_1core_1_1RegisterThis}{Register\+This}$<$ \hyperlink{classtheoria_1_1core_1_1AppConfigResolverComp}{App\+Config\+Resolver\+Comp} $>$ App\+Config\+Resolver\+Comp\+::rt\hspace{0.3cm}{\ttfamily [static]}}

Register factory

The documentation for this class was generated from the following files\+:\begin{DoxyCompactItemize}
\item
include/theoria/core/Core\+Components.\+h\item
src/core/Core\+Components.\+cpp\end{DoxyCompactItemize}


text:
using System.Security;

namespace Alphaleonis.Win32.Filesystem
{
   partial class Directory
   {
      #region .NET

      /// Determines whether the given path refers to an existing directory on disk.
      /// <returns>
      ///   <para>Returns <see langword="true"/> if <paramref name="path"/> refers to an existing directory.</para>
      ///   <para>Returns <see langword="false"/> if the directory does not exist or an error occurs when trying to determine if the specified file exists.</para>
      /// </returns>
      /// <remarks>
      ///   The Exists method returns <see langword="false"/> if any error occurs while trying to determine if the specified file exists.
      ///   This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,
      ///   a failing or missing disk, or if the caller does not have permission to read the file.
      /// </remarks>
      /// <param name="path">The path to test.</param>
      [SecurityCritical]
      public static bool Exists(string path)
      {
         return File.ExistsCore(true, null, path, PathFormat.RelativePath);
      }

      #endregion // .NET

      /// [AlphaFS] Determines whether the given path refers to an existing directory on disk.
      /// <returns>
      ///   <para>Returns <see langword="true"/> if <paramref name="path"/> refers to an existing directory.</para>
      ///   <para>Returns <see langword="false"/> if the directory does not exist or an error occurs when trying to determine if the specified file exists.</para>
      /// </returns>
      /// <remarks>
      ///   The Exists method returns <see langword="false"/> if any error occurs while trying to determine if the specified file exists.
      ///   This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,
      ///   a failing or missing disk, or if the caller does not have permission to read the file.
      /// </remarks>
      /// <param name="path">The path to test.</param>
      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
      [SecurityCritical]
      public static bool Exists(string path, PathFormat pathFormat)
      {
         return File.ExistsCore(true, null, path, pathFormat);
      }

      #region Transactional

      /// [AlphaFS] Determines whether the given path refers to an existing directory on disk.
      /// <returns>
      ///   <para>Returns <see langword="true"/> if <paramref name="path"/> refers to an existing directory.</para>
      ///   <para>Returns <see langword="false"/> if the directory does not exist or an error occurs when trying to determine if the specified file exists.</para>
      /// </returns>
      /// <remarks>
      ///   The Exists method returns <see langword="false"/> if any error occurs while trying to determine if the specified file exists.
      ///   This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,
      ///   a failing or missing disk, or if the caller does not have permission to read the file.
      /// </remarks>
      /// <param name="transaction">The transaction.</param>
      /// <param name="path">The path to test.</param>
      [SecurityCritical]
      public static bool ExistsTransacted(KernelTransaction transaction, string path)
      {
         return File.ExistsCore(true, transaction, path, PathFormat.RelativePath);
      }

      /// [AlphaFS] Determines whether the given path refers to an existing directory on disk.
      /// <returns>
      ///   <para>Returns <see langword="true"/> if <paramref name="path"/> refers to an existing directory.</para>
      ///   <para>Returns <see langword="false"/> if the directory does not exist or an error occurs when trying to determine if the specified file exists.</para>
      /// </returns>
      /// <remarks>
      ///   The Exists method returns <see langword="false"/> if any error occurs while trying to determine if the specified file exists.
      ///   This can occur in situations that raise exceptions such as passing a file name with invalid characters or too many characters,
      ///   a failing or missing disk, or if the caller does not have permission to read the file.
      /// </remarks>
      /// <param name="transaction">The transaction.</param>
      /// <param name="path">The path to test.</param>
      /// <param name="pathFormat">Indicates the format of the path parameter(s).</param>
      [SecurityCritical]
      public static bool ExistsTransacted(KernelTransaction transaction, string path, PathFormat pathFormat)
      {
         return File.ExistsCore(true, transaction, path, pathFormat);
      }

      #endregion // Transactional
   }
}


text:
$(document).on("pageinit",function() {
    getSensorInfo(5, 1);

    $("#settings").submit(function() {

    var post = {};
    post["sensor1Enabled"] = ($("#flip2b").val() == 'on') ? 1: 0;
    post["sensor2Enabled"] = ($("#flip2a").val() == 'on') ? 1: 0;
    post["temperatureAlarmMin"] = $("#range1a").val();
    post["temperatureAlarmMax"] = $("#range1b").val();
    post["notifyPerioidMinutes"] = $("#range1c").val();
    post["NUM_SECONDS"] = $("#range1d").val();

    $.ajax({
           type: "POST",
           url: "http://beaglebone-eth:8888/setSettings",
           data : post,
           dataType : "json",
           success: function(data)
           {

           }
         });

    return false; // avoid to execute the actual submit of the form.
    });
});

function getSensorInfo(count, sensor){
    $.ajax({
        type: "POST",
        url: "http://beaglebone-eth:8888/getSettings",
        data : {"type" : "all"},
        dataType : "json",
        success: function(data) {

            $("#flip2b").val((data.sensor1) ? 'on' : 'off').slider('refresh');
            $("#flip2a").val((data.sensor2) ? 'on' : 'off').slider('refresh');

            $("#range1a").val(data.temperatureAlarmMin);
            $("#range1b").val(data.temperatureAlarmMax).slider('refresh');

            $("#range1c").val(data.notifyPerioidMinutes).slider('refresh');
            $("#range1d").val(data.NUM_SECONDS).slider('refresh');
        }
    });
}


text:
/*
 * F32Handler.cpp
 *
 *  Created on: 15 maj 2014
 *      Author: MattLech
 */

#include "F32Handler.h"

static F32Handler *instance;

F32Handler *F32Handler::getInstance()
{
  if (!instance)
  {
    instance = new F32Handler();
  };
  return instance;
};

F32Handler::F32Handler()
{
}

int F32Handler::execute(Command *command)
{

  StatusList::getInstance()->readValue(command->getP());

  return 0;
}


text:
\hypertarget{_utils_8h}{}\section{C\+:/\+Users/\+Public/paramics/programmer/plugins/pveins/src/\+Tra\+C\+I\+A\+P\+I/\+Utils.h File Reference}
\label{_utils_8h}\index{C\+:/\+Users/\+Public/paramics/programmer/plugins/pveins/src/\+Tra\+C\+I\+A\+P\+I/\+Utils.\+h@{C\+:/\+Users/\+Public/paramics/programmer/plugins/pveins/src/\+Tra\+C\+I\+A\+P\+I/\+Utils.\+h}}
{\ttfamily \#include \char`\"{}storage.\+h\char`\"{}}\newline
{\ttfamily \#include $<$mutex$>$}\newline
{\ttfamily \#include \char`\"{}programmer.\+h\char`\"{}}\newline
{\ttfamily \#include \char`\"{}Constants.\+h\char`\"{}}\newline
Include dependency graph for Utils.\+h\+:
\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=350pt]{_utils_8h__incl}
\end{center}
\end{figure}
This graph shows which files directly or indirectly include this file\+:
\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=350pt]{_utils_8h__dep__incl}
\end{center}
\end{figure}
\subsection*{Classes}
\begin{DoxyCompactItemize}
\item
class \hyperlink{class_vector2_d}{Vector2D}
\item
class \hyperlink{class_vector3_d}{Vector3D}
\item
class \hyperlink{class_positional_data}{Positional\+Data}
\item
class \hyperlink{class_dimensional_data}{Dimensional\+Data}
\end{DoxyCompactItemize}
\subsection*{Namespaces}
\begin{DoxyCompactItemize}
\item
 \hyperlink{namespacetraci__api}{traci\+\_\+api}
\end{DoxyCompactItemize}
\subsection*{Functions}
\begin{DoxyCompactItemize}
\item
uint32\+\_\+t \hyperlink{_utils_8h_a61bb5ca333b6d62a492a4fe789939577}{R\+G\+B2\+H\+EX} (uint8\+\_\+t r, uint8\+\_\+t g, uint8\+\_\+t b)
\item
void \hyperlink{_utils_8h_a2a7f8de699335a756055f278f551e3b1}{H\+E\+X2\+R\+GB} (uint32\+\_\+t hex, uint8\+\_\+t \&r, uint8\+\_\+t \&g, uint8\+\_\+t \&b)
\item
void \hyperlink{namespacetraci__api_a8179b41c12626fc5444d12ee3a6f19cb}{traci\+\_\+api\+::debug\+Print} (std\+::string text)
\begin{DoxyCompactList}\small\item\em Convenience function, prints an std\+::string on Paramics\textquotesingle{} output window. \end{DoxyCompactList}\item
void \hyperlink{namespacetraci__api_a3d103fa606d4762c375bac42c66f62a8}{traci\+\_\+api\+::info\+Print} (std\+::string text)
\end{DoxyCompactItemize}
\begin{Indent}\textbf{ Helpers for reading and checking values}\par
\begin{DoxyCompactItemize}
\item
bool \hyperlink{namespacetraci__api_a57c1a8583619eb1e9984249249435f8e}{traci\+\_\+api\+::read\+Type\+Checking\+Int} (\hyperlink{classtcpip_1_1_storage}{tcpip\+::\+Storage} \&input\+Storage, int \&into)
\begin{DoxyCompactList}\small\item\em Reads the value type and an int, verifying the type. \end{DoxyCompactList}\item
bool \hyperlink{namespacetraci__api_a5229be0b43fc9f5d9f413d5e51924b50}{traci\+\_\+api\+::read\+Type\+Checking\+Double} (\hyperlink{classtcpip_1_1_storage}{tcpip\+::\+Storage} \&input\+Storage, double \&into)
\begin{DoxyCompactList}\small\item\em Reads the value type and a double, verifying the type. \end{DoxyCompactList}\item
bool \hyperlink{namespacetraci__api_ac51a66efdbed4dcdcef596643fe387ec}{traci\+\_\+api\+::read\+Type\+Checking\+String} (\hyperlink{classtcpip_1_1_storage}{tcpip\+::\+Storage} \&input\+Storage, std\+::string \&into)
\begin{DoxyCompactList}\small\item\em Reads the value type and a string, verifying the type. \end{DoxyCompactList}\item
bool \hyperlink{namespacetraci__api_aa16305c07ac5f8221d9099f2e3a7531c}{traci\+\_\+api\+::read\+Type\+Checking\+String\+List} (\hyperlink{classtcpip_1_1_storage}{tcpip\+::\+Storage} \&input\+Storage, std\+::vector$<$ std\+::string $>$ \&into)
\begin{DoxyCompactList}\small\item\em Reads the value type and a string list, verifying the type. \end{DoxyCompactList}\item
bool \hyperlink{namespacetraci__api_af8c7656fbd212acb13f037d4fb20f1f7}{traci\+\_\+api\+::read\+Type\+Checking\+Color} (\hyperlink{classtcpip_1_1_storage}{tcpip\+::\+Storage} \&input\+Storage, uint32\+\_\+t \&hex)
\begin{DoxyCompactList}\small\item\em Reads the value type and a color, verifying the type. \end{DoxyCompactList}\item
bool \hyperlink{namespacetraci__api_a26421201e19b2667e198708c2216ca06}{traci\+\_\+api\+::read\+Type\+Checking\+Position2D} (\hyperlink{classtcpip_1_1_storage}{tcpip\+::\+Storage} \&input\+Storage, \hyperlink{class_vector2_d}{Vector2D} \&into)
\begin{DoxyCompactList}\small\item\em Reads the value type and a 2D position, verifying the type. \end{DoxyCompactList}\item
bool \hyperlink{namespacetraci__api_aee58441392da7b83ecd8c8831271e945}{traci\+\_\+api\+::read\+Type\+Checking\+Byte} (\hyperlink{classtcpip_1_1_storage}{tcpip\+::\+Storage} \&input\+Storage, int8\+\_\+t \&into)
\begin{DoxyCompactList}\small\item\em Reads the value type and a 2D bounding box, verifying the type. \end{DoxyCompactList}\item
bool \hyperlink{namespacetraci__api_ac95893093cb3b220faafd74ce62abba3}{traci\+\_\+api\+::read\+Type\+Checking\+Unsigned\+Byte} (\hyperlink{classtcpip_1_1_storage}{tcpip\+::\+Storage} \&input\+Storage, uint8\+\_\+t \&into)
\begin{DoxyCompactList}\small\item\em Reads the value type and an unsigned byte, verifying the type. \end{DoxyCompactList}\end{DoxyCompactItemize}
\end{Indent}

\subsection{Function Documentation}
\mbox{\Hypertarget{_utils_8h_a2a7f8de699335a756055f278f551e3b1}\label{_utils_8h_a2a7f8de699335a756055f278f551e3b1}}
\index{Utils.\+h@{Utils.\+h}!H\+E\+X2\+R\+GB@{H\+E\+X2\+R\+GB}}
\index{H\+E\+X2\+R\+GB@{H\+E\+X2\+R\+GB}!Utils.\+h@{Utils.\+h}}
\subsubsection{\texorpdfstring{H\+E\+X2\+R\+G\+B()}{HEX2RGB()}}
{\footnotesize\ttfamily void H\+E\+X2\+R\+GB (\begin{DoxyParamCaption}\item[{uint32\+\_\+t}]{hex,  }\item[{uint8\+\_\+t \&}]{r,  }\item[{uint8\+\_\+t \&}]{g,  }\item[{uint8\+\_\+t \&}]{b }\end{DoxyParamCaption})}

Here is the caller graph for this function\+:
\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=348pt]{_utils_8h_a2a7f8de699335a756055f278f551e3b1_icgraph}
\end{center}
\end{figure}
\mbox{\Hypertarget{_utils_8h_a61bb5ca333b6d62a492a4fe789939577}\label{_utils_8h_a61bb5ca333b6d62a492a4fe789939577}}
\index{Utils.\+h@{Utils.\+h}!R\+G\+B2\+H\+EX@{R\+G\+B2\+H\+EX}}
\index{R\+G\+B2\+H\+EX@{R\+G\+B2\+H\+EX}!Utils.\+h@{Utils.\+h}}
\subsubsection{\texorpdfstring{R\+G\+B2\+H\+E\+X()}{RGB2HEX()}}
{\footnotesize\ttfamily uint32\+\_\+t R\+G\+B2\+H\+EX (\begin{DoxyParamCaption}\item[{uint8\+\_\+t}]{r,  }\item[{uint8\+\_\+t}]{g,  }\item[{uint8\+\_\+t}]{b }\end{DoxyParamCaption})}

Here is the caller graph for this function\+:
\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=348pt]{_utils_8h_a61bb5ca333b6d62a492a4fe789939577_icgraph}
\end{center}
\end{figure}


text:
package org.simpleapplications.skills;

import org.apache.commons.lang3.StringUtils;
import org.springframework.data.neo4j.annotation.GraphId;
import org.springframework.data.neo4j.annotation.NodeEntity;

@NodeEntity
public class Skill {

  @GraphId
  private Long id;
  private String code;
  private String name;
  private SkillLevel level;

  public Skill() {
  }

  public Skill(String code, String name, SkillLevel level) {
    validateCode(code);
    validateName(name);
    validateLevel(level);

    this.code = code;
    this.name = name;
    this.level = level;
  }

  public Skill(String code, String name, String level) {
    this(code, name, SkillLevel.valueOf(level));
  }

  private void validateLevel(SkillLevel level) {
    if (level == null) {
      throw new IllegalArgumentException("Level can not be null");
    }
  }

  private void validateName(String name) {
    if (StringUtils.isEmpty(name)) {
      throw new IllegalArgumentException("Name can not be null or empty");
    }
  }

  private void validateCode(String code) {
    if (StringUtils.isEmpty(code)) {
      throw new IllegalArgumentException("Code can not be null or empty");
    }
  }

  public String getCode() {
    return this.code;
  }

  public String getName() {
    return this.name;
  }

  public SkillLevel getLevel() {
    return this.level;
  }

  public Long getId() {
    return this.id;
  }

}


text:
@interface LLMWeatherDisplayData : LLMWeather
@end


text:
Bridge.merge(new System.Globalization.CultureInfo("uk", true), {
    englishName: "Ukrainian",
    nativeName: "українська",

    numberFormat: Bridge.merge(new System.Globalization.NumberFormatInfo(), {
        nanSymbol: "NaN",
        negativeSign: "-",
        positiveSign: "+",
        negativeInfinitySymbol: "-∞",
        positiveInfinitySymbol: "∞",
        percentSymbol: "%",
        percentGroupSizes: [3],
        percentDecimalDigits: 2,
        percentDecimalSeparator: ",",
        percentGroupSeparator: " ",
        percentPositivePattern: 1,
        percentNegativePattern: 1,
        currencySymbol: "₴",
        currencyGroupSizes: [3],
        currencyDecimalDigits: 2,
        currencyDecimalSeparator: ",",
        currencyGroupSeparator: " ",
        currencyNegativePattern: 8,
        currencyPositivePattern: 3,
        numberGroupSizes: [3],
        numberDecimalDigits: 2,
        numberDecimalSeparator: ",",
        numberGroupSeparator: " ",
        numberNegativePattern: 1
    }),

    dateTimeFormat: Bridge.merge(new System.Globalization.DateTimeFormatInfo(), {
        abbreviatedDayNames: ["Нд","Пн","Вт","Ср","Чт","Пт","Сб"],
        abbreviatedMonthGenitiveNames: ["січ","лют","бер","кві","тра","чер","лип","сер","вер","жов","лис","гру",""],
        abbreviatedMonthNames: ["Січ","Лют","Бер","Кві","Тра","Чер","Лип","Сер","Вер","Жов","Лис","Гру",""],
        amDesignator: "",
        dateSeparator: ".",
        dayNames: ["неділя","понеділок","вівторок","середа","четвер","п'ятниця","субота"],
        firstDayOfWeek: 1,
        fullDateTimePattern: "d MMMM yyyy' р.' H:mm:ss",
        longDatePattern: "d MMMM yyyy' р.'",
        longTimePattern: "H:mm:ss",
        monthDayPattern: "d MMMM",
        monthGenitiveNames: ["січня","лютого","березня","квітня","травня","червня","липня","серпня","вересня","жовтня","листопада","грудня",""],
        monthNames: ["січень","лютий","березень","квітень","травень","червень","липень","серпень","вересень","жовтень","листопад","грудень",""],
        pmDesignator: "",
        rfc1123: "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'",
        shortDatePattern: "dd.MM.yyyy",
        shortestDayNames: ["Нд","Пн","Вт","Ср","Чт","Пт","Сб"],
        shortTimePattern: "H:mm",
        sortableDateTimePattern: "yyyy'-'MM'-'dd'T'HH':'mm':'ss",
        sortableDateTimePattern1: "yyyy'-'MM'-'dd",
        timeSeparator: ":",
        universalSortableDateTimePattern: "yyyy'-'MM'-'dd HH':'mm':'ss'Z'",
        yearMonthPattern: "MMMM yyyy' р.'",
        roundtripFormat: "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffffffzzz"
    }),

    TextInfo: Bridge.merge(new System.Globalization.TextInfo(), {
        ANSICodePage: 1251,
        CultureName: "uk-UA",
        EBCDICCodePage: 500,
        IsRightToLeft: false,
        LCID: 1058,
        listSeparator: ";",
        MacCodePage: 10017,
        OEMCodePage: 866,
        IsReadOnly: true
    })
});


text:
namespace CustomFontDialog
{
    partial class FontDialog
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.label1 = new System.Windows.Forms.Label();
            this.label2 = new System.Windows.Forms.Label();
            this.lstSize = new System.Windows.Forms.ListBox();
            this.txtSize = new System.Windows.Forms.TextBox();
            this.chbBold = new System.Windows.Forms.CheckBox();
            this.chbItalic = new System.Windows.Forms.CheckBox();
            this.groupBox1 = new System.Windows.Forms.GroupBox();
            this.groupBox2 = new System.Windows.Forms.GroupBox();
            this.lblSampleText = new System.Windows.Forms.Label();
            this.btnCancel = new System.Windows.Forms.Button();
            this.btnOK = new System.Windows.Forms.Button();
            this.lstFont = new CustomFontDialog.FontList();
            this.groupBox1.SuspendLayout();
            this.groupBox2.SuspendLayout();
            this.SuspendLayout();
            //
            // label1
            //
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(13, 13);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(31, 13);
            this.label1.TabIndex = 0;
            this.label1.Text = "Font:";
            //
            // label2
            //
            this.label2.AutoSize = true;
            this.label2.Location = new System.Drawing.Point(187, 13);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(30, 13);
            this.label2.TabIndex = 3;
            this.label2.Text = "Size:";
            //
            // lstSize
            //
            this.lstSize.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.lstSize.FormattingEnabled = true;
            this.lstSize.Items.AddRange(new object[] {
            "8",
            "9",
            "10",
            "11",
            "12",
            "14",
            "16",
            "18",
            "20",
            "22",
            "24",
            "26",
            "28",
            "36",
            "48",
            "72"});
            this.lstSize.Location = new System.Drawing.Point(190, 50);
            this.lstSize.Name = "lstSize";
            this.lstSize.Size = new System.Drawing.Size(100, 171);
            this.lstSize.TabIndex = 4;
            this.lstSize.SelectedIndexChanged += new System.EventHandler(this.lstSize_SelectedIndexChanged);
            //
            // txtSize
            //
            this.txtSize.Location = new System.Drawing.Point(190, 30);
            this.txtSize.Name = "txtSize";
            this.txtSize.Size = new System.Drawing.Size(100, 20);
            this.txtSize.TabIndex = 5;
            this.txtSize.TextChanged += new System.EventHandler(this.txtSize_TextChanged);
            this.txtSize.KeyDown += new System.Windows.Forms.KeyEventHandler(this.txtSize_KeyDown);
            //
            // chbBold
            //
            this.chbBold.AutoSize = true;
            this.chbBold.Location = new System.Drawing.Point(21, 27);
            this.chbBold.Name = "chbBold";
            this.chbBold.Size = new System.Drawing.Size(47, 17);
            this.chbBold.TabIndex = 6;
            this.chbBold.Text = "Bold";
            this.chbBold.UseVisualStyleBackColor = true;
            this.chbBold.CheckedChanged += new System.EventHandler(this.chb_CheckedChanged);
            //
            // chbItalic
            //
            this.chbItalic.AutoSize = true;
            this.chbItalic.Location = new System.Drawing.Point(21, 50);
            this.chbItalic.Name = "chbItalic";
            this.chbItalic.Size = new System.Drawing.Size(48, 17);
            this.chbItalic.TabIndex = 7;
            this.chbItalic.Text = "Italic";
            this.chbItalic.UseVisualStyleBackColor = true;
            this.chbItalic.CheckedChanged += new System.EventHandler(this.chb_CheckedChanged);
            //
            // groupBox1
            //
            this.groupBox1.Controls.Add(this.chbBold);
            this.groupBox1.Controls.Add(this.chbItalic);
            this.groupBox1.Location = new System.Drawing.Point(312, 13);
            this.groupBox1.Name = "groupBox1";
            this.groupBox1.Size = new System.Drawing.Size(113, 83);
            this.groupBox1.TabIndex = 8;
            this.groupBox1.TabStop = false;
            this.groupBox1.Text = "Font Style";
            //
            // groupBox2
            //
            this.groupBox2.Controls.Add(this.lblSampleText);
            this.groupBox2.Location = new System.Drawing.Point(190, 238);
            this.groupBox2.Name = "groupBox2";
            this.groupBox2.Size = new System.Drawing.Size(235, 79);
            this.groupBox2.TabIndex = 9;
            this.groupBox2.TabStop = false;
            this.groupBox2.Text = "Sample Text";
            //
            // lblSampleText
            //
            this.lblSampleText.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.lblSampleText.Location = new System.Drawing.Point(6, 16);
            this.lblSampleText.Name = "lblSampleText";
            this.lblSampleText.Size = new System.Drawing.Size(223, 53);
            this.lblSampleText.TabIndex = 0;
            this.lblSampleText.Text = "AaBbCcXxYyZz";
            this.lblSampleText.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            //
            // btnCancel
            //
            this.btnCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.btnCancel.Location = new System.Drawing.Point(350, 327);
            this.btnCancel.Name = "btnCancel";
            this.btnCancel.Size = new System.Drawing.Size(75, 23);
            this.btnCancel.TabIndex = 10;
            this.btnCancel.Text = "Cancel";
            this.btnCancel.UseVisualStyleBackColor = true;
            //
            // btnOK
            //
            this.btnOK.DialogResult = System.Windows.Forms.DialogResult.OK;
            this.btnOK.Location = new System.Drawing.Point(269, 327);
            this.btnOK.Name = "btnOK";
            this.btnOK.Size = new System.Drawing.Size(75, 23);
            this.btnOK.TabIndex = 11;
            this.btnOK.Text = "OK";
            this.btnOK.UseVisualStyleBackColor = true;
            //
            // lstFont
            //
            this.lstFont.Location = new System.Drawing.Point(16, 30);
            this.lstFont.Name = "lstFont";
            this.lstFont.SelectedFontFamily = null;
            this.lstFont.Size = new System.Drawing.Size(150, 289);
            this.lstFont.TabIndex = 1;
            //
            // FontDialog
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(450, 362);
            this.Controls.Add(this.btnOK);
            this.Controls.Add(this.btnCancel);
            this.Controls.Add(this.groupBox2);
            this.Controls.Add(this.groupBox1);
            this.Controls.Add(this.txtSize);
            this.Controls.Add(this.lstSize);
            this.Controls.Add(this.label2);
            this.Controls.Add(this.lstFont);
            this.Controls.Add(this.label1);
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
            this.Name = "FontDialog";
            this.ShowIcon = false;
            this.Text = "Font";
            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FontDialog_FormClosing);
            this.groupBox1.ResumeLayout(false);
            this.groupBox1.PerformLayout();
            this.groupBox2.ResumeLayout(false);
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Label label1;
        private FontList lstFont;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.ListBox lstSize;
        private System.Windows.Forms.TextBox txtSize;
        private System.Windows.Forms.CheckBox chbBold;
        private System.Windows.Forms.CheckBox chbItalic;
        private System.Windows.Forms.GroupBox groupBox1;
        private System.Windows.Forms.GroupBox groupBox2;
        private System.Windows.Forms.Label lblSampleText;
        private System.Windows.Forms.Button btnCancel;
        private System.Windows.Forms.Button btnOK;
    }
}


text:
"""
Test for jacobian/hessian functions in Theano
"""
from __future__ import absolute_import, print_function, division
from six.moves import xrange
from theano.tests import unittest_tools as utt
import theano
from theano import tensor
import numpy

utt.seed_rng()

def test001_jacobian_vector():
    x = tensor.vector()
    y = x * 2
    rng = numpy.random.RandomState(seed=utt.fetch_seed())

    # test when the jacobian is called with a tensor as wrt
    Jx = tensor.jacobian(y, x)
    f = theano.function([x], Jx)
    vx = rng.uniform(size=(10,)).astype(theano.config.floatX)
    assert numpy.allclose(f(vx), numpy.eye(10) * 2)

    # test when the jacobian is called with a tuple as wrt
    Jx = tensor.jacobian(y, (x,))
    assert isinstance(Jx, tuple)
    f = theano.function([x], Jx[0])
    vx = rng.uniform(size=(10,)).astype(theano.config.floatX)
    assert numpy.allclose(f(vx), numpy.eye(10) * 2)

    # test when the jacobian is called with a list as wrt
    Jx = tensor.jacobian(y, [x])
    assert isinstance(Jx, list)
    f = theano.function([x], Jx[0])
    vx = rng.uniform(size=(10,)).astype(theano.config.floatX)
    assert numpy.allclose(f(vx), numpy.eye(10) * 2)

    # test when the jacobian is called with a list of two elements
    z = tensor.vector()
    y = x * z
    Js = tensor.jacobian(y, [x, z])
    f = theano.function([x, z], Js)
    vx = rng.uniform(size=(10,)).astype(theano.config.floatX)
    vz = rng.uniform(size=(10,)).astype(theano.config.floatX)
    vJs = f(vx, vz)
    evx = numpy.zeros((10, 10))
    evz = numpy.zeros((10, 10))
    numpy.fill_diagonal(evx, vx)
    numpy.fill_diagonal(evz, vz)
    assert numpy.allclose(vJs[0], evz)
    assert numpy.allclose(vJs[1], evx)

def test002_jacobian_matrix():
    x = tensor.matrix()
    y = 2 * x.sum(axis=0)
    rng = numpy.random.RandomState(seed=utt.fetch_seed())
    ev = numpy.zeros((10, 10, 10))
    for dx in xrange(10):
        ev[dx, :, dx] = 2.

    # test when the jacobian is called with a tensor as wrt
    Jx = tensor.jacobian(y, x)
    f = theano.function([x], Jx)
    vx = rng.uniform(size=(10, 10)).astype(theano.config.floatX)
    assert numpy.allclose(f(vx), ev)

    # test when the jacobian is called with a tuple as wrt
    Jx = tensor.jacobian(y, (x,))
    assert isinstance(Jx, tuple)
    f = theano.function([x], Jx[0])
    vx = rng.uniform(size=(10, 10)).astype(theano.config.floatX)
    assert numpy.allclose(f(vx), ev)

    # test when the jacobian is called with a list as wrt
    Jx = tensor.jacobian(y, [x])
    assert isinstance(Jx, list)
    f = theano.function([x], Jx[0])
    vx = rng.uniform(size=(10, 10)).astype(theano.config.floatX)
    assert numpy.allclose(f(vx), ev)

    # test when the jacobian is called with a list of two elements
    z = tensor.matrix()
    y = (x * z).sum(axis=1)
    Js = tensor.jacobian(y, [x, z])
    f = theano.function([x, z], Js)
    vx = rng.uniform(size=(10, 10)).astype(theano.config.floatX)
    vz = rng.uniform(size=(10, 10)).astype(theano.config.floatX)
    vJs = f(vx, vz)
    evx = numpy.zeros((10, 10, 10))
    evz = numpy.zeros((10, 10, 10))
    for dx in xrange(10):
        evx[dx, dx, :] = vx[dx, :]
        evz[dx, dx, :] = vz[dx, :]
    assert numpy.allclose(vJs[0], evz)
    assert numpy.allclose(vJs[1], evx)

def test003_jacobian_scalar():
    x = tensor.scalar()
    y = x * 2
    rng = numpy.random.RandomState(seed=utt.fetch_seed())

    # test when the jacobian is called with a tensor as wrt
    Jx = tensor.jacobian(y, x)
    f = theano.function([x], Jx)
    vx = numpy.cast[theano.config.floatX](rng.uniform())
    assert numpy.allclose(f(vx), 2)

    # test when the jacobian is called with a tuple as wrt
    Jx = tensor.jacobian(y, (x,))
    assert isinstance(Jx, tuple)
    f = theano.function([x], Jx[0])
    vx = numpy.cast[theano.config.floatX](rng.uniform())
    assert numpy.allclose(f(vx), 2)

    # test when the jacobian is called with a list as wrt
    Jx = tensor.jacobian(y, [x])
    assert isinstance(Jx, list)
    f = theano.function([x], Jx[0])
    vx = numpy.cast[theano.config.floatX](rng.uniform())
    assert numpy.allclose(f(vx), 2)

    # test when the jacobian is called with a list of two elements
    z = tensor.scalar()
    y = x * z
    Jx = tensor.jacobian(y, [x, z])
    f = theano.function([x, z], Jx)
    vx = numpy.cast[theano.config.floatX](rng.uniform())
    vz = numpy.cast[theano.config.floatX](rng.uniform())
    vJx = f(vx, vz)

    assert numpy.allclose(vJx[0], vz)
    assert numpy.allclose(vJx[1], vx)

def test004_hessian():
    x = tensor.vector()
    y = tensor.sum(x ** 2)
    Hx = tensor.hessian(y, x)
    f = theano.function([x], Hx)
    vx = numpy.arange(10).astype(theano.config.floatX)
    assert numpy.allclose(f(vx), numpy.eye(10) * 2)

def test_jacobian_disconnected_inputs():
    """
    Test that disconnected inputs are properly handled by jacobian.
    """
    v1 = tensor.vector()
    v2 = tensor.vector()
    jacobian_v = theano.gradient.jacobian(1 + v1, v2, disconnected_inputs='ignore')
    func_v = theano.function([v1, v2], jacobian_v)
    val = numpy.arange(4.0).astype(theano.config.floatX)
    assert numpy.allclose(func_v(val, val), numpy.zeros((4, 4)))

    s1 = tensor.scalar()
    s2 = tensor.scalar()
    jacobian_s = theano.gradient.jacobian(1 + s1, s2, disconnected_inputs='ignore')
    func_s = theano.function([s2], jacobian_s)
    val = numpy.array(1.0).astype(theano.config.floatX)
    assert numpy.allclose(func_s(val), numpy.zeros(1))


text:
/**
 * @requires OpenLayers/Control.js
 */

/**
 * Class: OpenLayers.Control.ZoomOut
 * The ZoomOut control is a button to decrease the zoom level of a map.
 *
 * Inherits from:
 *  - <OpenLayers.Control>
 */
OpenLayers.Control.ZoomOut = OpenLayers.Class(OpenLayers.Control, {

    /**
     * Property: type
     * {String} The type of <OpenLayers.Control> -- When added to a
     *     <Control.Panel>, 'type' is used by the panel to determine how to
     *     handle our events.
     */
    type: OpenLayers.Control.TYPE_BUTTON,

    /**
     * Method: trigger
     */
    trigger: function(){
        this.map.zoomOut();
    },

    CLASS_NAME: "OpenLayers.Control.ZoomOut"
});


text:
package bentolor.grocerylist;

import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebFilter;
import org.springframework.web.server.WebFilterChain;
import reactor.core.publisher.Mono;

/**
 * Dirty hack to redirect / to /index.html.
 * @see
 *     https://github.com/spring-projects/spring-boot/issues/9785
 */
@Component
public class RedirectToIndexHtmlWebFilter implements WebFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        if (exchange.getRequest().getURI().getPath().equals("/")) {
            return chain.filter(exchange.mutate()
                    .request(exchange.getRequest().mutate().path("/index.html").build())
                    .build());
        }

        return chain.filter(exchange);
    }
}


text:
CATALINA_HOME=/usr/local/apache-tomcat-6.0.35

perl -pi -w -e 's/qa./nightly./g;' $CATALINA_HOME/lib/tenants/core/local-settings.xml;$CATALINA_HOME/bin/catalina.sh stop;$CATALINA_HOME/bin/catalina.sh start;


text:
import React, { Component } from 'react'
import logo from './logo.svg'
import './App.css'
import TextInputContainer from './TextInputContainer'
import { connect } from 'react-redux'
import * as inputActionCreators from './TextInputContainer/Store'
import { bindActionCreators } from 'redux'

class App extends Component {
  render() {
    const { addInput } = this.props

    return (

Redux

             addInput({side: 'left', value: 'Left'})}>Add input
            <TextInputContainer
              side={'left'}
            />

             addInput({value: 'Center'})}>Add input
            <TextInputContainer
              side={'default'}
              defaultValue={'Center -> defaultValue'}
            />

             addInput({side: 'right', value: 'Right'})}>Add input
            <TextInputContainer
              side={'right'}
            />

    )
  }
}

const mapStateToProps = state => ({ ...state })

const mapDispatchToProps = dispatch => ({
  ...bindActionCreators(inputActionCreators, dispatch)
})

export default connect(
  mapStateToProps,
  mapDispatchToProps
)(App)


text:
package main

import (
	"fmt"
	"log"
	"net/http"

	"github.com/zgiber/gears"
	"golang.org/x/net/context"
)

func gearHeaderExample(c context.Context, w http.ResponseWriter, r *http.Request) context.Context {

	var err error

	// something happened
	// err = fmt.Errorf("Something bad happened") // uncomment to see how errors are returned

	if err != nil {
		// something didn't work out..
		errCtx := gears.NewErrorContext(c, gears.NewStatusError(http.StatusInternalServerError, "Sorry, just can't..."))
		return errCtx
	}

	// otherwise do your thing
	w.Header().Set("Content-Type", "application/json")
	return c
}

func gearTokenExample(c context.Context, w http.ResponseWriter, r *http.Request) context.Context {

	// otherwise do your thing
	token := r.Header.Get("Authorization")
	w.Header().Set("Authorization", token) // just so we see something in the result..
	return context.WithValue(c, "token", token)
}

func gearErrorExample(c context.Context, w http.ResponseWriter, r *http.Request) context.Context {

	// let's say we have an error here
	err := fmt.Errorf("Can't do that, sorry... would you like a hot beverage?")
	return gears.NewErrorContext(c, gears.NewStatusError(http.StatusInternalServerError, err.Error()))
}

func mainHandler(c context.Context, w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("{\"message\":\"Hello World\"}"))
}

func main() {

	base := gears.Chain(gearHeaderExample, gears.New(mainHandler))

	// single middleware
	http.Handle("/main", base)

	// extend base handler with a new gear (middleware)
	http.Handle("/main/extended", gears.Chain(base, gearTokenExample))

	// chain middleware in the handler constructor...
	http.Handle("/error", gears.Chain(gearErrorExample, gearHeaderExample, gears.New(mainHandler)))

	//...or chain middleware before using them in the constructor
	gearBox := gears.Chain(gearTokenExample, gearHeaderExample)
	http.Handle("/gearbox", gears.Chain(gearBox, gears.New(mainHandler)))

	// tip: chained middleware can be chained further.
	log.Fatal(http.ListenAndServe(":8080", nil))
}


text:
package org.apache.struts2.views.xslt;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.Result;
import com.opensymphony.xwork2.inject.Inject;
import com.opensymphony.xwork2.util.TextParseUtil;
import com.opensymphony.xwork2.util.ValueStack;
import com.opensymphony.xwork2.util.logging.Logger;
import com.opensymphony.xwork2.util.logging.LoggerFactory;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.StrutsConstants;
import org.apache.struts2.StrutsException;

import javax.servlet.http.HttpServletResponse;
import javax.xml.transform.ErrorListener;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Templates;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.URIResolver;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

/**
 *
 *
 * XSLTResult uses XSLT to transform an action object to XML. The recent version
 * has been specifically modified to deal with Xalan flaws. When using Xalan you
 * may notice that even though you have a very minimal stylesheet like this one
 *

 * <xsl:template match="/result">
 *   <result/>
 * </xsl:template>

 *
 *

 * Xalan would still iterate through every property of your action and all
 * its descendants.
 *

 *
 *

 * If you had double-linked objects, Xalan would work forever analysing an
 * infinite object tree. Even if your stylesheet was not constructed to process
 * them all. It's because the current Xalan eagerly and extensively converts
 * everything to its internal DTM model before further processing.
 *

 *
 *

 * That's why there's a loop eliminator added that works by indexing every
 * object-property combination during processing. If it notices that some
 * object's property was already walked through, it doesn't go any deeper.
 * Say you have two objects, x and y, with the following properties set
 * (pseudocode):
 *

 *

 * x.y = y;
 * and
 * y.x = x;
 * action.x=x;

 *
 *

 * Due to that modification, the resulting XML document based on x would be:
 *

 *
 *

 * <result>
 *   <x>
 *     <y/>
 *   </x>
 * </result>

 *
 *

 * Without it there would be endless x/y/x/y/x/y/... elements.
 *

 *
 *

 * The XSLTResult code tries also to deal with the fact that DTM model is built
 * in a manner that children are processed before siblings. The result is that if
 * there is object x that is both set in action's x property, and very deeply
 * under action's a property then it would only appear under a, not under x.
 * That's not what we expect, and that's why XSLTResult allows objects to repeat
 * in various places to some extent.
 *

 *
 *

 * Sometimes the object mesh is still very dense and you may notice that even
 * though you have a relatively simple stylesheet, execution takes a tremendous
 * amount of time. To help you to deal with that obstacle of Xalan, you may
 * attach regexp filters to elements paths (xpath).
 *

 *
 *

 * Note: In your .xsl file the root match must be named <tt>result</tt>.
 *
This example will output the username by using <tt>getUsername</tt> on your
 * action class:
 *

 * <xsl:template match="result">
 *   <html>
 *   <body>
 *   Hello <xsl:value-of select="username"/> how are you?
 *   </body>
 *   </html>
 * </xsl:template>
 *

 *
 *

 * In the following example the XSLT result would only walk through action's
 * properties without their childs. It would also skip every property that has
 * "hugeCollection" in their name. Element's path is first compared to
 * excludingPattern - if it matches it's no longer processed. Then it is
 * compared to matchingPattern and processed only if there's a match.
 *

 *
 *
 *
 *

 * <result name="success" type="xslt">
 *   <param name="location">foo.xslt</param>
 *   <param name="matchingPattern">^/result/[^/*]$</param>
 *   <param name="excludingPattern">.*(hugeCollection).*</param>
 * </result>
 *

 *
 *

 * In the following example the XSLT result would use the action's user property
 * instead of the action as it's base document and walk through it's properties.
 * The exposedValue uses an ognl expression to derive it's value.
 *

 *
 *

 * <result name="success" type="xslt">
 *   <param name="location">foo.xslt</param>
 *   <param name="exposedValue">user$</param>
 * </result>
 *

 * *
 * This result type takes the following parameters:
 *
 *
 *
 *

 *
 *
location (default) - the location to go to after execution.

 *
encoding - character encoding used in XML, default UTF-8.

 *
 *
parse - true by default. If set to false, the location param will
 * not be parsed for Ognl expressions.

 *
 *
 *
 *

 *
 *

 * struts.properties related configuration:
 *

 *

 *
 *
struts.xslt.nocache - Defaults to false. If set to true, disables
 * stylesheet caching. Good for development, bad for production.

 *
 *

 *
 *
 *
 * Example:
 *
 *

 * <result name="success" type="xslt">foo.xslt</result>
 *

 *
 */
public class XSLTResult implements Result {

    private static final long serialVersionUID = 6424691441777176763L;

    /** Log instance for this result. */
    private static final Logger LOG = LoggerFactory.getLogger(XSLTResult.class);

    /** 'stylesheetLocation' parameter.  Points to the xsl. */
    public static final String DEFAULT_PARAM = "stylesheetLocation";

    /** Cache of all tempaltes. */
    private static final Map<String, Templates> templatesCache;

    static {
        templatesCache = new HashMap<String, Templates>();
    }

    // Configurable Parameters

    /** Determines whether or not the result should allow caching. */
    protected boolean noCache;

    /** Indicates the location of the xsl template. */
    private String stylesheetLocation;

    /** Indicates the property name patterns which should be exposed to the xml. */
    private String matchingPattern;

    /** Indicates the property name patterns which should be excluded from the xml. */
    private String excludingPattern;

    /** Indicates the ognl expression respresenting the bean which is to be exposed as xml. */
    private String exposedValue;

    /** Indicates the status to return in the response */
    private int status = 200;

    private String encoding = "UTF-8";

    private boolean parse;
    private AdapterFactory adapterFactory;

    public XSLTResult() {
    }

    public XSLTResult(String stylesheetLocation) {
        this();
        setStylesheetLocation(stylesheetLocation);
    }

    @Inject(StrutsConstants.STRUTS_XSLT_NOCACHE)
    public void setNoCache(String val) {
        noCache = "true".equals(val);
    }

    /**
     * @deprecated Use #setStylesheetLocation(String)
     */
    public void setLocation(String location) {
        setStylesheetLocation(location);
    }

    public void setStylesheetLocation(String location) {
        if (location == null)
            throw new IllegalArgumentException("Null location");
        this.stylesheetLocation = location;
    }

    public String getStylesheetLocation() {
        return stylesheetLocation;
    }

    public String getExposedValue() {
        return exposedValue;
    }

    public void setExposedValue(String exposedValue) {
        this.exposedValue = exposedValue;
    }

    /**
     * @deprecated Since 2.1.1
     */
    public String getMatchingPattern() {
        return matchingPattern;
    }

    /**
     * @deprecated Since 2.1.1
     */
    public void setMatchingPattern(String matchingPattern) {
        this.matchingPattern = matchingPattern;
    }

    /**
     * @deprecated Since 2.1.1
     */
    public String getExcludingPattern() {
        return excludingPattern;
    }

    /**
     * @deprecated Since 2.1.1
     */
    public void setExcludingPattern(String excludingPattern) {
        this.excludingPattern = excludingPattern;
    }

    public String getStatus() {
        return String.valueOf(status);
    }

    public void setStatus(String status) {
        try {
            this.status = Integer.valueOf(status);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Status value not number " + e.getMessage(), e);
        }
    }

    public String getEncoding() {
        return encoding;
    }

    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }

    /**
     * If true, parse the stylesheet location for OGNL expressions.
     *
     * @param parse
     */
    public void setParse(boolean parse) {
        this.parse = parse;
    }

    public void execute(ActionInvocation invocation) throws Exception {
        long startTime = System.currentTimeMillis();
        String location = getStylesheetLocation();

        if (parse) {
            ValueStack stack = ActionContext.getContext().getValueStack();
            location = TextParseUtil.translateVariables(location, stack);
        }

        try {
            HttpServletResponse response = ServletActionContext.getResponse();
            response.setStatus(status);
            response.setCharacterEncoding(encoding);
            PrintWriter writer = response.getWriter();

            // Create a transformer for the stylesheet.
            Templates templates = null;
            Transformer transformer;
            if (location != null) {
                templates = getTemplates(location);
                transformer = templates.newTransformer();
            } else
                transformer = TransformerFactory.newInstance().newTransformer();

            transformer.setURIResolver(getURIResolver());
            transformer.setErrorListener(new ErrorListener() {

                public void error(TransformerException exception)
                        throws TransformerException {
                    throw new StrutsException("Error transforming result", exception);
                }

                public void fatalError(TransformerException exception)
                        throws TransformerException {
                    throw new StrutsException("Fatal error transforming result", exception);
                }

                public void warning(TransformerException exception)
                        throws TransformerException {
                    if (LOG.isWarnEnabled()) {
                	LOG.warn(exception.getMessage(), exception);
                    }
                }

            });

            String mimeType;
            if (templates == null)
                mimeType = "text/xml"; // no stylesheet, raw xml
            else
                mimeType = templates.getOutputProperties().getProperty(OutputKeys.MEDIA_TYPE);
            if (mimeType == null) {
                // guess (this is a servlet, so text/html might be the best guess)
                mimeType = "text/html";
            }

            response.setContentType(mimeType);

            Object result = invocation.getAction();
            if (exposedValue != null) {
                ValueStack stack = invocation.getStack();
                result = stack.findValue(exposedValue);
            }

            Source xmlSource = getDOMSourceForStack(result);

            // Transform the source XML to System.out.
            if (LOG.isDebugEnabled()) {
        	LOG.debug("xmlSource = " + xmlSource);
            }
            transformer.transform(xmlSource, new StreamResult(writer));

            writer.flush(); // ...and flush...

            if (LOG.isDebugEnabled()) {
                LOG.debug("Time:" + (System.currentTimeMillis() - startTime) + "ms");
            }

        } catch (Exception e) {
            if (LOG.isErrorEnabled()) {
                LOG.error("Unable to render XSLT Template, '#0'", e, location);
            }
            throw e;
        }
    }

    protected AdapterFactory getAdapterFactory() {
        if (adapterFactory == null)
            adapterFactory = new AdapterFactory();
        return adapterFactory;
    }

    protected void setAdapterFactory(AdapterFactory adapterFactory) {
        this.adapterFactory = adapterFactory;
    }

    /**
     * Get the URI Resolver to be called by the processor when it encounters an xsl:include, xsl:import, or document()
     * function. The default is an instance of ServletURIResolver, which operates relative to the servlet context.
     */
    protected URIResolver getURIResolver() {
        return new ServletURIResolver(
                ServletActionContext.getServletContext());
    }

    protected Templates getTemplates(String path) throws TransformerException, IOException {
        String pathFromRequest = ServletActionContext.getRequest().getParameter("xslt.location");

        if (pathFromRequest != null)
            path = pathFromRequest;

        if (path == null)
            throw new TransformerException("Stylesheet path is null");

        Templates templates = templatesCache.get(path);

        if (noCache || (templates == null)) {
            synchronized (templatesCache) {
                URL resource = ServletActionContext.getServletContext().getResource(path);

                if (resource == null) {
                    throw new TransformerException("Stylesheet " + path + " not found in resources.");
                }

                if (LOG.isDebugEnabled()) {
                    LOG.debug("Preparing XSLT stylesheet templates: " + path);
                }

                TransformerFactory factory = TransformerFactory.newInstance();
                factory.setURIResolver(getURIResolver());
                templates = factory.newTemplates(new StreamSource(resource.openStream()));
                templatesCache.put(path, templates);
            }
        }

        return templates;
    }

    protected Source getDOMSourceForStack(Object value)
            throws IllegalAccessException, InstantiationException {
        return new DOMSource(getAdapterFactory().adaptDocument("result", value) );
    }
}


text:
static NSString * const kFolderKey = @"application/vnd.google-apps.folder";

@implementation ItemDriveServiceFile

+(NSArray <ItemDriveServiceFile*>*)getItemDriveServiceFilesFrom:(NSArray <GTLDriveFile *>*)files {
    NSMutableArray * resFiles = [NSMutableArray arrayWithCapacity:files.count];
    for (GTLDriveFile * file in files) {
        ItemDriveServiceFile * fileRes = [[ItemDriveServiceFile alloc] initWithGTLDriveFile:file];
        [resFiles addObject:fileRes];
    }
    return resFiles;
}

-(instancetype)initWithGTLDriveFile:(GTLDriveFile *)file {
    self = [super init];
    if (self) {
        self.extention = [file.fileExtension lowercaseString];
        self.identifier = file.identifier;
        self.title = file.name;
        NSString *url = [NSString stringWithFormat:@"https://www.googleapis.com/drive/v3/files/%@?alt=media", file.identifier];
        self.serverPath = url;

        NSString *fileExtension = file.fileExtension;
        if ([file.mimeType isEqualToString:kFolderKey]) {
            self.fileType = FSFileTypeFolder;
        } else if ([fileExtension isEqualToString:@"doc"]) {
            self.fileType = FSFileTypeDoc;
        } else if ([fileExtension isEqualToString:@"docx"]) {
            self.fileType = FSFileTypeDocx;
        } else if([fileExtension isEqualToString:@"pdf"]) {
            self.fileType = FSFileTypePdf;
        } else if ([file.mimeType isEqualToString:@"application/vnd.google-apps.document"]) {
            self.fileType = FSFileTypeDoc;
        } else {
            self.fileType = FSFileTypeOther;
        }
    }
    return self;
}

-(BOOL)isFolder {
    return (self.fileType == FSFileTypeFolder);
}

-(BOOL)isTrashed {
    return self.trashed.boolValue;
}

@end