text:
/**
 * @requires OpenLayers/Format/OWSCommon.js
 */

/**
 * Class: OpenLayers.Format.OWSCommon.v1
 * Common readers and writers for OWSCommon v1.X formats
 *
 * Inherits from:
 *  - <OpenLayers.Format.XML>
 */
OpenLayers.Format.OWSCommon.v1 = OpenLayers.Class(OpenLayers.Format.XML, {

    /**
     * Property: regExes
     * Compiled regular expressions for manipulating strings.
     */
    regExes: {
        trimSpace: (/^\s*|\s*$/g),
        removeSpace: (/\s*/g),
        splitSpace: (/\s+/),
        trimComma: (/\s*,\s*/g)
    },

    /**
     * Method: read
     *
     * Parameters:
     * data - {DOMElement} An OWSCommon document element.
     * options - {Object} Options for the reader.
     *
     * Returns:
     * {Object} An object representing the OWSCommon document.
     */
    read: function(data, options) {
        options = OpenLayers.Util.applyDefaults(options, this.options);
        var ows = {};
        this.readChildNodes(data, ows);
        return ows;
    },

    /**
     * Property: readers
     * Contains public functions, grouped by namespace prefix, that will
     *     be applied when a namespaced node is found matching the function
     *     name.  The function will be applied in the scope of this parser
     *     with two arguments: the node being read and a context object passed
     *     from the parent.
     */
    readers: {
        "ows": {
            "Exception": function(node, exceptionReport) {
                var exception = {
                    code: node.getAttribute('exceptionCode'),
                    locator: node.getAttribute('locator'),
                    texts: []
                };
                exceptionReport.exceptions.push(exception);
                this.readChildNodes(node, exception);
            },
            "ExceptionText": function(node, exception) {
                var text = this.getChildValue(node);
                exception.texts.push(text);
            },
            "ServiceIdentification": function(node, obj) {
                obj.serviceIdentification = {};
                this.readChildNodes(node, obj.serviceIdentification);
            },
            "Title": function(node, obj) {
                obj.title = this.getChildValue(node);
            },
            "Abstract": function(node, serviceIdentification) {
                serviceIdentification["abstract"] = this.getChildValue(node);
            },
            "Keywords": function(node, serviceIdentification) {
                serviceIdentification.keywords = {};
                this.readChildNodes(node, serviceIdentification.keywords);
            },
            "Keyword": function(node, keywords) {
                keywords[this.getChildValue(node)] = true;
            },
            "ServiceType": function(node, serviceIdentification) {
                serviceIdentification.serviceType = {
                    codeSpace: node.getAttribute('codeSpace'),
                    value: this.getChildValue(node)};
            },
            "ServiceTypeVersion": function(node, serviceIdentification) {
                serviceIdentification.serviceTypeVersion = this.getChildValue(node);
            },
            "Fees": function(node, serviceIdentification) {
                serviceIdentification.fees = this.getChildValue(node);
            },
            "AccessConstraints": function(node, serviceIdentification) {
                serviceIdentification.accessConstraints =
                    this.getChildValue(node);
            },
            "ServiceProvider": function(node, obj) {
                obj.serviceProvider = {};
                this.readChildNodes(node, obj.serviceProvider);
            },
            "ProviderName": function(node, serviceProvider) {
                serviceProvider.providerName = this.getChildValue(node);
            },
            "ProviderSite": function(node, serviceProvider) {
                serviceProvider.providerSite = this.getAttributeNS(node,
                    this.namespaces.xlink, "href");
            },
            "ServiceContact": function(node, serviceProvider) {
                serviceProvider.serviceContact = {};
                this.readChildNodes(node, serviceProvider.serviceContact);
            },
            "IndividualName": function(node, serviceContact) {
                serviceContact.individualName = this.getChildValue(node);
            },
            "PositionName": function(node, serviceContact) {
                serviceContact.positionName = this.getChildValue(node);
            },
            "ContactInfo": function(node, serviceContact) {
                serviceContact.contactInfo = {};
                this.readChildNodes(node, serviceContact.contactInfo);
            },
            "Phone": function(node, contactInfo) {
                contactInfo.phone = {};
                this.readChildNodes(node, contactInfo.phone);
            },
            "Voice": function(node, phone) {
                phone.voice = this.getChildValue(node);
            },
            "Address": function(node, contactInfo) {
                contactInfo.address = {};
                this.readChildNodes(node, contactInfo.address);
            },
            "DeliveryPoint": function(node, address) {
                address.deliveryPoint = this.getChildValue(node);
            },
            "City": function(node, address) {
                address.city = this.getChildValue(node);
            },
            "AdministrativeArea": function(node, address) {
                address.administrativeArea = this.getChildValue(node);
            },
            "PostalCode": function(node, address) {
                address.postalCode = this.getChildValue(node);
            },
            "Country": function(node, address) {
                address.country = this.getChildValue(node);
            },
            "ElectronicMailAddress": function(node, address) {
                address.electronicMailAddress = this.getChildValue(node);
            },
            "Role": function(node, serviceContact) {
                serviceContact.role = this.getChildValue(node);
            },
            "OperationsMetadata": function(node, obj) {
                obj.operationsMetadata = {};
                this.readChildNodes(node, obj.operationsMetadata);
            },
            "Operation": function(node, operationsMetadata) {
                var name = node.getAttribute("name");
                operationsMetadata[name] = {};
                this.readChildNodes(node, operationsMetadata[name]);
            },
            "DCP": function(node, operation) {
                operation.dcp = {};
                this.readChildNodes(node, operation.dcp);
            },
            "HTTP": function(node, dcp) {
                dcp.http = {};
                this.readChildNodes(node, dcp.http);
            },
            "Get": function(node, http) {
                if (!http.get) {
                    http.get = [];
                }
                var obj = {
                    url: this.getAttributeNS(node, this.namespaces.xlink, "href")
                };
                this.readChildNodes(node, obj);
                http.get.push(obj);
            },
            "Post": function(node, http) {
                if (!http.post) {
                    http.post = [];
                }
                var obj = {
                    url: this.getAttributeNS(node, this.namespaces.xlink, "href")
                };
                this.readChildNodes(node, obj);
                http.post.push(obj);
            },
            "Parameter": function(node, operation) {
                if (!operation.parameters) {
                    operation.parameters = {};
                }
                var name = node.getAttribute("name");
                operation.parameters[name] = {};
                this.readChildNodes(node, operation.parameters[name]);
            },
            "Constraint": function(node, obj) {
                if (!obj.constraints) {
                    obj.constraints = {};
                }
                var name = node.getAttribute("name");
                obj.constraints[name] = {};
                this.readChildNodes(node, obj.constraints[name]);
            },
            "Value": function(node, allowedValues) {
                allowedValues[this.getChildValue(node)] = true;
            },
            "OutputFormat": function(node, obj) {
                obj.formats.push({value: this.getChildValue(node)});
                this.readChildNodes(node, obj);
            },
            "WGS84BoundingBox": function(node, obj) {
                var boundingBox = {};
                boundingBox.crs = node.getAttribute("crs");
                if (obj.BoundingBox) {
                    obj.BoundingBox.push(boundingBox);
                } else {
                    obj.projection = boundingBox.crs;
                    boundingBox = obj;
               }
               this.readChildNodes(node, boundingBox);
            },
            "BoundingBox": function(node, obj) {
                // FIXME: We consider that BoundingBox is the same as WGS84BoundingBox
                // LowerCorner = "min_x min_y"
                // UpperCorner = "max_x max_y"
                // It should normally depend on the projection
                this.readers['ows']['WGS84BoundingBox'].apply(this, [node, obj]);
            },
            "LowerCorner": function(node, obj) {
                var str = this.getChildValue(node).replace(
                    this.regExes.trimSpace, "");
                str = str.replace(this.regExes.trimComma, ",");
                var pointList = str.split(this.regExes.splitSpace);
                obj.left = pointList[0];
                obj.bottom = pointList[1];
            },
            "UpperCorner": function(node, obj) {
                var str = this.getChildValue(node).replace(
                    this.regExes.trimSpace, "");
                str = str.replace(this.regExes.trimComma, ",");
                var pointList = str.split(this.regExes.splitSpace);
                obj.right = pointList[0];
                obj.top = pointList[1];
                obj.bounds = new OpenLayers.Bounds(obj.left, obj.bottom,
                    obj.right, obj.top);
                delete obj.left;
                delete obj.bottom;
                delete obj.right;
                delete obj.top;
            },
            "Language": function(node, obj) {
                obj.language = this.getChildValue(node);
            }
        }
    },

    /**
     * Property: writers
     * As a compliment to the readers property, this structure contains public
     *     writing functions grouped by namespace alias and named like the
     *     node names they produce.
     */
    writers: {
        "ows": {
            "BoundingBox": function(options, nodeName) {
                var node = this.createElementNSPlus(nodeName || "ows:BoundingBox", {
                    attributes: {
                        crs: options.projection
                    }
                });
                this.writeNode("ows:LowerCorner", options, node);
                this.writeNode("ows:UpperCorner", options, node);
                return node;
            },
            "LowerCorner": function(options) {
                var node = this.createElementNSPlus("ows:LowerCorner", {
                    value: options.bounds.left + " " + options.bounds.bottom });
                return node;
            },
            "UpperCorner": function(options) {
                var node = this.createElementNSPlus("ows:UpperCorner", {
                    value: options.bounds.right + " " + options.bounds.top });
                return node;
            },
            "Identifier": function(identifier) {
                var node = this.createElementNSPlus("ows:Identifier", {
                    value: identifier });
                return node;
            },
            "Title": function(title) {
                var node = this.createElementNSPlus("ows:Title", {
                    value: title });
                return node;
            },
            "Abstract": function(abstractValue) {
                var node = this.createElementNSPlus("ows:Abstract", {
                    value: abstractValue });
                return node;
            },
            "OutputFormat": function(format) {
                var node = this.createElementNSPlus("ows:OutputFormat", {
                    value: format });
                return node;
            }
        }
    },

    CLASS_NAME: "OpenLayers.Format.OWSCommon.v1"

});


text: define({title:"Nouveau",background:"Arrière plan"});

redpajama_set_name: RedPajamaGithub


text:
/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2014 Couchbase, Inc
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

#ifndef SRC_THREADLOCAL_WIN32_H_
#define SRC_THREADLOCAL_WIN32_H_ 1

#ifndef SRC_THREADLOCAL_H_
#error "Include threadlocal.h instead"
#endif

#include <cstdlib>
#include <sstream>
#include <cstring>
#include <system_error>
#include <iostream>
#include <string>

#include <platform/strerror.h>

/**
 * Container of thread-local data.
 */
template<typename T>
class ThreadLocalWin32 {
public:
    ThreadLocalWin32() {
        tlsIndex = TlsAlloc();
        if (tlsIndex == TLS_OUT_OF_INDEXES) {
            DWORD err = GetLastError();
            std::string msg("Failed to create thread local storage: ");
            msg.append(cb_strerror(err));
            throw std::system_error(err, std::system_category(), msg);
        }
    }

    ~ThreadLocalWin32() {
        if (!TlsFree(tlsIndex)) {
            std::cerr << "~ThreadLocalPosix() TlsFree: "
                      << cb_strerror() << std::endl;
            std::cerr.flush();
        }
    }

    void set(const T &newValue) {
        if (!TlsSetValue(tlsIndex, newValue)) {
            DWORD err = GetLastError();
            std::string msg("Failed to store thread specific value: ");
            msg.append(cb_strerror(err));
            throw std::system_error(err, std::system_category(), msg);
        }
    }

    T get() const {
        return reinterpret_cast<T>(TlsGetValue(tlsIndex));
    }

    void operator =(const T &newValue) {
        set(newValue);
    }

    operator T() const {
        return get();
    }

private:
    DWORD tlsIndex;
};

#endif  // SRC_THREADLOCAL_WIN32_H_


text:
using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;
using Toolbox.NETMF.Hardware;

namespace Wii_Nunchuk
{
    public class Program
    {
        public static void Main()
        {
            WiiNunchuk Nunchuk = new WiiNunchuk();

            while (true)
            {
                // Reads all values
                Nunchuk.Read();

                // Prints out all values
                string Output = "Analog stick: " + Nunchuk.AnalogStickX.ToString() + "x" + Nunchuk.AnalogStickY.ToString();
                Output += " / Accellerometer: " + Nunchuk.AcceleroMeterX.ToString() + "x" + Nunchuk.AcceleroMeterY.ToString() + "x" + Nunchuk.AcceleroMeterZ.ToString();
                Output += " / C-Button: " + Nunchuk.ButtonC.ToString();
                Output += " / Z-Button: " + Nunchuk.ButtonZ.ToString();
                Debug.Print(Output);

                Thread.Sleep(1000);
            }
        }

    }
}


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

namespace QCmd.Cef
{
    class LocalSchemeHandler : ISchemeHandler
    {
        public bool ProcessRequestAsync(IRequest request, ISchemeHandlerResponse response, OnRequestCompletedHandler requestCompletedCallback)
        {
            var uri = new Uri(request.Url);
            var fileName = string.Format("{0}{1}", uri.Authority, uri.AbsolutePath);

            if (fileName[fileName.Length - 1] == '/')
                fileName = fileName.Substring(0, fileName.Length - 1);

            if (File.Exists(fileName))
            {
                var fileBytes = File.ReadAllBytes(fileName);
                response.ResponseStream = new MemoryStream(fileBytes);

                switch (Path.GetExtension(fileName))
                {
                    case ".html":
                        response.MimeType = "text/html";
                        break;
                    case ".js":
                        response.MimeType = "text/javascript";
                        break;
                    case ".css":
                        response.MimeType = "text/css";
                        break;
                    default:
                        response.MimeType = "application/octet-stream";
                        break;
                }

                requestCompletedCallback();
                return true;
            }
            return false;
        }
    }

    class LocalSchemeHandlerFactory : ISchemeHandlerFactory
    {
        public ISchemeHandler Create()
        {
            return new LocalSchemeHandler();
        }
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style name="Theme.NoActionBar" parent="@style/Theme.AppCompat.Light">
        <item name="windowActionBar">false</item>
        <item name="windowNoTitle">true</item>
    </style>
</resources>


text:
"""
WSGI middleware
"""

import logging, logging.config
import json

import werkzeug

from . import metrics, exceptions, py3comp

log = logging.getLogger("appmetrics.wsgi")

class AppMetricsMiddleware(object):
    """
    WSGI middleware for AppMetrics

    Usage:

    Instantiate me with the wrapped WSGI application. This middleware looks for request paths starting
    with "/_app-metrics": if not found, the wrapped application is called. The following resources are defined:

    ``/_app-metrics/metrics``
      - **GET**: return the list of the registered metrics
    ``/_app-metrics/metrics/<name>``
      - **GET**: return the value of the given metric or ``404``.
      - **PUT**: create a new metric with the given name. The body must be a ``JSON`` object with a
        mandatory attribute named ``"type"`` which must be one of the metrics types allowed,
        by the ``"metrics.METRIC_TYPES"`` dictionary, while the other attributes are
        passed to the ``new_<type>`` function as keyword arguments.
        Request's ``content-type`` must be ``"application/json"``.
      - **POST**: add a new value to the metric. The body must be a ``JSON`` object with a mandatory
        attribute named ``"value"``: the notify method will be called with the given value.
        Other attributes are ignored.
        Request's ``content-type`` must be ``"application/json"``.
      - **DELETE**: remove the metric with the given name. Return "deleted" or "not deleted".
    ``/_app-metrics/tags``
      - **GET**: return the list of registered tags
    ``/_app-metrics/tags/<name>``
      - **GET**: return the metrics tagged with the given tag. If the value of the ``GET`` parameter ``"expand"``
        is ``"true"``, a JSON object is returned, with the name of each tagged metric as keys and corresponding values.
        If it is ``"false"`` or not provided, the list of metric names is returned.
        Return a ``404`` if the tag does not exist
    ``/_app-metrics/tags/<tag_name>/<metric_name>``
      - **PUT**: tag the metric named ``<metric_name>`` with ``<tag_name>``. Return a ``400`` if the given metric
        does not exist.
      - **DELETE**: remove the tag ``<tag_name>`` from ``<metric_name>``. Return "deleted" or "not deleted". If
        ``<tag_name>`` is no longer used, it gets implicitly removed.

    The root can be different from "/_app-metrics", you can set it on middleware constructor.
    """

    def __init__(self, app, root="_app-metrics", extra_headers=None, mimetype="application/json"):
        """
        parameters:
        - app: wrapped WSGI application
        - root: path root to look for
        - extra_headers: extra headers that will be appended to the return headers
        """
        self.app = app
        self.root = "/" + root.strip("/").strip()
        self.extra_headers = extra_headers or {}
        self.mimetype = mimetype

        self.url_map = werkzeug.routing.Map([
            werkzeug.routing.Submount(self.root, [
                werkzeug.routing.Rule("/metrics", endpoint=handle_metrics_list, methods=['GET']),
                werkzeug.routing.Rule("/metrics/<name>", endpoint=handle_metric_show, methods=['GET']),
                werkzeug.routing.Rule("/metrics/<name>", endpoint=handle_metric_new, methods=['PUT']),
                werkzeug.routing.Rule("/metrics/<name>", endpoint=handle_metric_update, methods=['POST']),
                werkzeug.routing.Rule("/metrics/<name>", endpoint=handle_metric_delete, methods=['DELETE']),
                werkzeug.routing.Rule("/tags", endpoint=handle_tags_list, methods=['GET']),
                werkzeug.routing.Rule("/tags/<tag_name>", endpoint=handle_tag_show, methods=['GET']),
                werkzeug.routing.Rule("/tags/<tag_name>/<metric_name>", endpoint=handle_tag_add, methods=['PUT']),
                werkzeug.routing.Rule("/tags/<tag_name>/<metric_name>", endpoint=handle_untag, methods=['DELETE']),
            ])
        ])

    def get_response(self, body, code, headers=None):
        if headers is None:
            headers = []
        headers = dict(headers).copy()
        headers.update(self.extra_headers)
        return werkzeug.wrappers.Response(body, code, headers.items(), self.mimetype)

    def jsonize_error(self, exception, environ):
        return self.get_response(json.dumps(exception.description), exception.code, exception.get_headers(environ))

    def __call__(self, environ, start_response):
        """WSGI application interface"""

        urls = self.url_map.bind_to_environ(environ)

        try:
            endpoint, args = urls.match()
        except werkzeug.exceptions.NotFound:
            # the request did not match, go on with wsgi stack
            return self.app(environ, start_response)

        except werkzeug.exceptions.HTTPException as e:
            response = self.jsonize_error(e, environ)

        else:
            request = werkzeug.wrappers.Request(environ, populate_request=False)
            try:
                body = endpoint(request, **args)
                response = self.get_response(body, 200)
            except werkzeug.exceptions.HTTPException as e:
                response = self.jsonize_error(e, environ)

            except Exception as e:
                log.debug("Unhandled exception: %s", e, exc_info=True)
                response = self.get_response("Internal Server Error", 500)

        return response(environ, start_response)

def get_body(request):
    # get content type
    ctype = request.mimetype
    if not ctype or ctype != "application/json":
        raise werkzeug.exceptions.UnsupportedMediaType()

    # get content data
    try:
        return py3comp.json_load(request.stream, request.charset)
    except ValueError as e:
        log.debug("Invalid body: %s", e)
        raise werkzeug.exceptions.BadRequest(description="invalid json")

def handle_metrics_list(request):
    return json.dumps(metrics.metrics())

def handle_metric_show(request, name):
    try:
        metric = metrics.metric(name)
    except KeyError:
        raise werkzeug.exceptions.NotFound(("No such metric: {!r}".format(name)))

    return json.dumps(metric.get())

def handle_metric_delete(request, name):
    res = metrics.delete_metric(name)

    return "deleted" if res else "not deleted"

def handle_metric_new(request, name):
    data = get_body(request)

    type_ = data.pop('type', None)
    if not type_:
        raise werkzeug.exceptions.BadRequest(description="metric type not provided")

    metric_type = metrics.METRIC_TYPES.get(type_)

    if not metric_type:
        raise werkzeug.exceptions.BadRequest("invalid metric type: {!r}".format(type_))

    try:
        metric_type(name, **data)
    except exceptions.AppMetricsError as e:
        raise werkzeug.exceptions.BadRequest("can't create metric {}({!r}): {}".format(type_, name, e))
    except Exception as e:
        log.debug(str(e), exc_info=True)
        raise werkzeug.exceptions.BadRequest("can't create metric {}({!r})".format(type_, name))

    return ""

def handle_metric_update(request, name):
    data = get_body(request)

    value = data.pop('value', None)
    if value is None:
        raise werkzeug.exceptions.BadRequest("metric value not provided")

    try:
        metric = metrics.metric(name)
    except KeyError:
        raise werkzeug.exceptions.NotFound()

    metric.notify(value)

    return ""

def handle_tags_list(request):
    return json.dumps(sorted(metrics.tags().keys()))

def handle_tag_show(request, tag_name):
    all_tags = metrics.tags()
    if tag_name not in all_tags:
        raise werkzeug.exceptions.NotFound(description="no such tag: {!r}".format(tag_name))

    if request.args.get('expand', 'false') == 'true':
        return json.dumps(metrics.metrics_by_tag(tag_name))
    else:
        return json.dumps(sorted(all_tags[tag_name]))

def handle_tag_add(request, tag_name, metric_name):
    try:
        metrics.tag(metric_name, tag_name)
    except metrics.InvalidMetricError as e:
        raise werkzeug.exceptions.BadRequest(description=str(e))

    return ""

def handle_untag(request, tag_name, metric_name):
    res = metrics.untag(metric_name, tag_name)

    return "deleted" if res else "not deleted"

# useful to run standalone with werkzeug's server:
# $ python -m werkzeug.serving appmetrics.wsgi.standalone_app
# * Running on http://127.0.0.1:5000/

standalone_app = AppMetricsMiddleware(werkzeug.exceptions.NotFound(), "")


text:
using System;
using System.IO;

namespace PrepareRelease
{
    internal class Program
    {
        // Default values
        //TODO: Make it possible to overwrite these in args of main.
        private static readonly bool checkSpreadsheets = true;
        private static readonly bool generateHelp = true;
        private static readonly bool checkExampleSheetsAreValid = checkSpreadsheets && generateHelp && true;
        private static readonly bool generateInstallerResources = true;
        public static string Rootpath = @"c:\dev\QuantSAFolder\QuantSA";
        public static string XllPath = @"C:\dev\QuantSAFolder\QuantSA\QuantSA\QuantSA.Excel.AddIn\bin\Debug\QuantSA.xll";

        private static void Main(string[] args)
        {
            // Variables
            var rootpath = Rootpath;
            var xllPath = Path.Combine(rootpath, XllPath);
            var exampleSheetPath = Path.Combine(rootpath, @"ExcelExamples");
            var tempOutputPath = Path.Combine(rootpath, @"temp");

            MarkdownGenerator generator = null;
            SpreadsheetChecker ssChecker = null;

            // Check spreadsheets
            if (checkSpreadsheets)
            {
                ssChecker = new SpreadsheetChecker(xllPath, exampleSheetPath, tempOutputPath);
                var failedSheets = ssChecker.Check();
                Console.WriteLine("Running example sheets: " + failedSheets + " errors. (see " +
                                  SpreadsheetChecker.ERROR_OUTPUT_FILE + ")");
            }

            // Generate the help
            if (generateHelp)
            {
                string[] dllsWithExposedFunctions =
                {
                    Path.Combine(rootpath, @"QuantSA\QuantSA.Excel.Addin\bin\Debug\QuantSA.Excel.Addin.dll"),
                    Path.Combine(rootpath, @"QuantSA\QuantSA.Excel.Addin\bin\Debug\QuantSA.ExcelFunctions.dll")
                };
                var outputPath = Path.Combine(rootpath, @"Documentation\");
                var helpURL = "http://www.quantsa.org/";
                generator = new MarkdownGenerator(dllsWithExposedFunctions, outputPath, helpURL, tempOutputPath);
                var failedMarkdown = generator.Generate();
                Console.WriteLine("Generating markdown: " + failedMarkdown + " errors. (see " +
                                  MarkdownGenerator.MD_ERROR_OUTPUT_FILE + ")");
            }

            // Check the example sheets are valid.  This means that each example sheet referenced in the
            // help comments actually maps to an example sheet in the install directory.
            if (checkExampleSheetsAreValid)
            {
                if (!generateHelp || !checkSpreadsheets)
                    throw new Exception(
                        "Can only check if spreadsheets are valid if 'generateHelp' and 'checkSpreadsheets' are set to True.");
                var failedExampleSheetRefs = generator.AreAllExampleSheetsValid(ssChecker.GetSheetsAndFuncs());
                Console.WriteLine("Checking valid example sheets: " + failedExampleSheetRefs + " errors. (see " +
                                  MarkdownGenerator.SS_ERROR_OUTPUT_FILE + ")");
            }

            // Generate the installer resource files
            if (generateInstallerResources)
            {
                var installFilesPartialPath = Path.Combine(@"QuantSA\QuantSA.Excel.Addin\bin\Release");
                var installFileGenerator = new InstallerGenerator(rootpath, installFilesPartialPath);
                installFileGenerator.Generate();
            }

            // Wait for keyboard
            Console.WriteLine("Finished.  Press any key...");
            Console.ReadKey();
        }
    }
}


text:
package com.amazonaws.services.fsx.model.transform;

import javax.annotation.Generated;

import com.amazonaws.SdkClientException;
import com.amazonaws.services.fsx.model.*;

import com.amazonaws.protocol.*;
import com.amazonaws.annotation.SdkInternalApi;

/**
 * ActiveDirectoryBackupAttributesMarshaller
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
@SdkInternalApi
public class ActiveDirectoryBackupAttributesMarshaller {

    private static final MarshallingInfo<String> DOMAINNAME_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("DomainName").build();
    private static final MarshallingInfo<String> ACTIVEDIRECTORYID_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("ActiveDirectoryId").build();

    private static final ActiveDirectoryBackupAttributesMarshaller instance = new ActiveDirectoryBackupAttributesMarshaller();

    public static ActiveDirectoryBackupAttributesMarshaller getInstance() {
        return instance;
    }

    /**
     * Marshall the given parameter object.
     */
    public void marshall(ActiveDirectoryBackupAttributes activeDirectoryBackupAttributes, ProtocolMarshaller protocolMarshaller) {

        if (activeDirectoryBackupAttributes == null) {
            throw new SdkClientException("Invalid argument passed to marshall(...)");
        }

        try {
            protocolMarshaller.marshall(activeDirectoryBackupAttributes.getDomainName(), DOMAINNAME_BINDING);
            protocolMarshaller.marshall(activeDirectoryBackupAttributes.getActiveDirectoryId(), ACTIVEDIRECTORYID_BINDING);
        } catch (Exception e) {
            throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
        }
    }

}