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

package org.sweble.wikitext.engine.utils;

import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Collection;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.commons.collections.map.MultiValueMap;
import org.sweble.wikitext.engine.config.I18nAliasImpl;
import org.sweble.wikitext.engine.config.InterwikiImpl;
import org.sweble.wikitext.engine.config.NamespaceImpl;
import org.sweble.wikitext.engine.config.WikiConfig;
import org.sweble.wikitext.engine.config.WikiConfigImpl;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * @author Samy Ateia, samyateia@hotmail.de
 *
 */
public class LanguageConfigGenerator
{
	public static final String API_ENDPOINT_MAGICWORDS = ".wikipedia.org/w/api.php?action=query&meta=siteinfo&siprop=magicwords&format=xml";
	public static final String API_ENDPOINT_INTERWIKIMAP = ".wikipedia.org/w/api.php?action=query&meta=siteinfo&siprop=interwikimap&format=xml";
	public static final String API_ENDPOINT_NAMESPACES = ".wikipedia.org/w/api.php?action=query&meta=siteinfo&siprop=namespaces&format=xml";
	public static final String API_ENDPOINT_NAMESPACEALIASES = ".wikipedia.org/w/api.php?action=query&meta=siteinfo&siprop=namespacealiases&format=xml";

	public static WikiConfig generateWikiConfig(String languagePrefix) throws IOException,
		ParserConfigurationException, SAXException
	{
		return generateWikiConfig(languagePrefix + " wiki", "https://" + languagePrefix + ".wikipedia.org",
			languagePrefix);
	}

	public static WikiConfig generateWikiConfig(String siteName, String siteURL, String languagePrefix)
		throws IOException, ParserConfigurationException, SAXException
	{
		String endpointPrefix = "https://" + languagePrefix;
		return generateWikiConfig(siteName, siteURL, languagePrefix, endpointPrefix+API_ENDPOINT_NAMESPACEALIASES,
			endpointPrefix+API_ENDPOINT_NAMESPACES, endpointPrefix+API_ENDPOINT_INTERWIKIMAP, endpointPrefix+API_ENDPOINT_MAGICWORDS);
	}

	public static WikiConfig generateWikiConfig(String siteName, String siteUrl, String languagePrefix,
		String apiUrlNamespacealiases, String apiUrlNamespaces, String apiUrlInterwikimap, String apiUrlMagicwords) throws IOException, ParserConfigurationException, SAXException
	{
		WikiConfigImpl wikiConfig = new WikiConfigImpl();
		wikiConfig.setSiteName(siteName);
		wikiConfig.setWikiUrl(siteUrl);
		wikiConfig.setContentLang(languagePrefix);
		wikiConfig.setIwPrefix(languagePrefix);

		DefaultConfigEnWp config = new DefaultConfigEnWp();
		config.configureEngine(wikiConfig);

		MultiValueMap namespaceAliases = getNamespaceAliases(apiUrlNamespacealiases);
		addNamespaces(wikiConfig, apiUrlNamespaces, namespaceAliases);
		addInterwikis(wikiConfig, apiUrlInterwikimap);
		addi18NAliases(wikiConfig, apiUrlMagicwords);

		config.addParserFunctions(wikiConfig);
		config.addTagExtensions(wikiConfig);

		return wikiConfig;
	}

	public static void addi18NAliases(WikiConfigImpl wikiConfig, String apiUrlMagicWords) throws IOException,
		ParserConfigurationException, SAXException
	{
		Document document = getXMLFromUlr(apiUrlMagicWords);
		NodeList apiI18NAliases = document.getElementsByTagName("magicword");

		for (int i = 0; i < apiI18NAliases.getLength(); i++)
		{
			Node apii18NAlias = apiI18NAliases.item(i);
			NamedNodeMap attributes = apii18NAlias.getAttributes();

			String name = attributes.getNamedItem("name").getNodeValue();
			boolean iscaseSensitive = false;
			Node caseSensitive = attributes.getNamedItem("case-sensitive");
			if (caseSensitive != null)
			{
				iscaseSensitive = true;
			}

			Node aliasesNode = apii18NAlias.getFirstChild();
			NodeList aliasesList = aliasesNode.getChildNodes();
			ArrayList<String> aliases = new ArrayList<String>();
			for (int j = 0; j < aliasesList.getLength(); j++)
			{
				Node aliasNode = aliasesList.item(j);
				String aliasString = aliasNode.getTextContent();
				aliases.add(aliasString);
			}
			I18nAliasImpl I18Alias = new I18nAliasImpl(name, iscaseSensitive, aliases);
			try
			{
				wikiConfig.addI18nAlias(I18Alias);
			} catch (Exception e)
			{
				// TODO resolve conflicts problem
				e.printStackTrace();
			}
		}
	}

	public static void addInterwikis(WikiConfigImpl wikiConfig, String apiUrlInterwikiMap) throws IOException,
		ParserConfigurationException, SAXException
	{
		Document document = getXMLFromUlr(apiUrlInterwikiMap);
		NodeList apiInterwikis = document.getElementsByTagName("iw");

		for (int i = 0; i < apiInterwikis.getLength(); i++)
		{
			Node apiInterWiki = apiInterwikis.item(i);
			NamedNodeMap attributes = apiInterWiki.getAttributes();

			String prefixString = attributes.getNamedItem("prefix").getNodeValue();

			boolean isLocal = false; // if present set true else false
			Node localNode = attributes.getNamedItem("local");
			if (localNode != null)
			{
				isLocal = true;
			}
			boolean isTrans = false; // TODO check dokumentation if really always false?
			String urlStringApi = attributes.getNamedItem("url").getNodeValue();

			InterwikiImpl interwiki = new InterwikiImpl(prefixString, urlStringApi, isLocal, isTrans);
			wikiConfig.addInterwiki(interwiki);
		}
	}

	public static void addNamespaces(WikiConfigImpl wikiConfig, String apiUrlNamespaces, MultiValueMap nameSpaceAliases)
		throws IOException, ParserConfigurationException, SAXException
	{
		Document document = getXMLFromUlr(apiUrlNamespaces);
		NodeList apiNamespaces = document.getElementsByTagName("ns");

		for (int i = 0; i < apiNamespaces.getLength(); i++)
		{
			Node apiNamespace = apiNamespaces.item(i);
			String name = apiNamespace.getTextContent();
			NamedNodeMap attributes = apiNamespace.getAttributes();
			Integer id = new Integer(attributes.getNamedItem("id").getNodeValue());
			String canonical = "";
			if (attributes.getNamedItem("canonical") != null)
			{
				canonical = attributes.getNamedItem("canonical").getNodeValue();
			}

			boolean fileNs = false;
			if (canonical.equals("File"))
			{
				fileNs = true;
			}

			Node subpages = attributes.getNamedItem("subpages");
			boolean canHaveSubpages = false;
			if (subpages != null)
			{
				canHaveSubpages = true;
			}

			Collection<String> aliases = new ArrayList<String>();
			if (nameSpaceAliases.containsKey(id))
			{
				aliases = (Collection<String>) nameSpaceAliases.getCollection(id);
			}

			NamespaceImpl namespace = new NamespaceImpl(id.intValue(), name, canonical, canHaveSubpages, fileNs,
				aliases);
			wikiConfig.addNamespace(namespace);

			if (canonical.equals("Template"))
			{
				wikiConfig.setTemplateNamespace(namespace);
			}
			else if (id.intValue() == 0)
			{
				wikiConfig.setDefaultNamespace(namespace);
			}

		}
	}

	public static MultiValueMap getNamespaceAliases(String apiUrlNamespaceAliases) throws IOException,
		ParserConfigurationException, SAXException
	{
		Document document = getXMLFromUlr(apiUrlNamespaceAliases);
		NodeList namespaceAliasess = document.getElementsByTagName("ns");
		MultiValueMap namespaces = new MultiValueMap();

		for (int i = 0; i < namespaceAliasess.getLength(); i++)
		{
			Node aliasNode = namespaceAliasess.item(i);
			NamedNodeMap attributes = aliasNode.getAttributes();

			Integer id = new Integer(attributes.getNamedItem("id").getNodeValue());
			String aliasString = aliasNode.getTextContent();
			namespaces.put(id, aliasString);
		}
		return namespaces;
	}

	public static Document getXMLFromUlr(String urlString) throws IOException, ParserConfigurationException,
		SAXException
	{
		URL url = new URL(urlString);
		URLConnection connection = url.openConnection();
		DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
		DocumentBuilder docBuilder = documentBuilderFactory.newDocumentBuilder();
		Document document = docBuilder.parse(connection.getInputStream());
		return document;
	}

}


text:
<link rel="import" href="display-component/chart-selector.html">
<link rel="import" href="display-component/chart-selector.html">
<link rel="import" href="display-component/settings-component.html">
<link rel="import" href="display-component/legends-component.html">
<link rel="stylesheet" href="polymer-d3-global.css">
<dom-module id="polymer-d3">
  <template>

    <template is="dom-if" if="[[ editMode ]]" restamp>

        <chart-selector
          charts="[[availableCharts]]"
          selected="{{selectedChart}}"
        ></chart-selector>

    </template>

  </template>

</dom-module>

redpajama_set_name: RedPajamaGithub


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
package com.azure.resourcemanager.privatedns.implementation;

import com.azure.resourcemanager.privatedns.fluent.models.RecordSetInner;
import com.azure.resourcemanager.privatedns.models.RecordType;
import com.azure.resourcemanager.privatedns.models.TxtRecord;
import com.azure.resourcemanager.privatedns.models.TxtRecordSet;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/** Implementation of {@link TxtRecordSet}. */
class TxtRecordSetImpl extends PrivateDnsRecordSetImpl implements TxtRecordSet {
    TxtRecordSetImpl(final String name, final PrivateDnsZoneImpl parent, final RecordSetInner innerModel) {
        super(name, RecordType.TXT.toString(), parent, innerModel);
    }

    static TxtRecordSetImpl newRecordSet(final String name, final PrivateDnsZoneImpl parent) {
        return new TxtRecordSetImpl(name, parent, new RecordSetInner().withTxtRecords(new ArrayList<>()));
    }

    @Override
    public List<TxtRecord> records() {
        if (innerModel().txtRecords() != null) {
            return Collections.unmodifiableList(innerModel().txtRecords());
        }
        return Collections.unmodifiableList(new ArrayList<>());
    }

    @Override
    protected RecordSetInner prepareForUpdate(RecordSetInner resource) {
        if (innerModel().txtRecords() != null && innerModel().txtRecords().size() > 0) {
            if (resource.txtRecords() == null) {
                resource.withTxtRecords(new ArrayList<>());
            }
            resource.txtRecords().addAll(innerModel().txtRecords());
            innerModel().txtRecords().clear();
        }
        if (recordSetRemoveInfo.txtRecords().size() > 0) {
            if (resource.txtRecords() != null) {
                for (TxtRecord recordToRemove : recordSetRemoveInfo.txtRecords()) {
                    for (TxtRecord record : resource.txtRecords()) {
                        boolean exists = record.value().equals(recordToRemove.value());
                        if (exists) {
                            resource.txtRecords().remove(record);
                            break;
                        }
                    }
                }
            }
            recordSetRemoveInfo.txtRecords().clear();
        }
        return resource;
    }
}


text:
'use strict';

/**
* Dependencies
*/
var express = require('express'),
    path = require('path'),
    morgan = require('morgan'),
    routes = require('./routes'),
    bodyParser = require('body-parser'),
    backoffice = require('./routes/backoffice'),
    multer = require('multer'),
    passport = require('passport'),
    favicon = require('serve-favicon'),
    fs = require('fs'),
    authController = require('./controllers/authentication');

function Server(options) {
  var server;
  /**
  * Init stuff
  */
  var app = express(),
      router = express.Router();

  var upload = multer({ storage: multer.memoryStorage() });

  app.set('port', options.port || process.env.PORT || 8080);
  app.set('ip', process.env.HOST || 'localhost');

  app.use(passport.initialize());
  app.use(favicon(path.join(__dirname,'public/img/panic-button-128.png')));

  app.use(bodyParser.urlencoded({ extended: false })); // parse application/x-www-form-urlencoded
  app.use(bodyParser.json()); // parse application/json

  app.set('view engine', 'jade');
  app.set('views', path.join(__dirname,'public'));

  app.use(express.static(path.join(__dirname, 'public')));
  app.use(express.static(path.join(__dirname, 'bower_components')));

  if(process.env.NODE_ENV === 'development') {
    app.use(morgan('dev'));
  } else {
    var logFile = (process.env.LOG_DIR || __dirname) + '/morgan.log';
    var accessLogStream = fs.createWriteStream(logFile, {flags: 'a'})
    app.use(morgan('common', { skip: function(req, res) { return res.statusCode < 400 }, stream: accessLogStream }));
  }

  app.get('/', routes.index);
  app.get('/admin', authController.isAuthenticated, backoffice.index);

  app.get('/panic-button', routes.panicButton);

  app.get('/beer-detail', function(req, res) {
    res.render('views/beer-detail', { title: 'Beer' })
  });

  app.post('/beer-detail', routes.randomBeer);
  app.post('/beer-detail/:beerId', routes.beerDetail);
  app.post('/beer-name-exists/:beerName', routes.beerNameExists);

  app.get('/beer-list', authController.isAuthenticated, backoffice.beerList);
  app.get('/beer-preview', authController.isAuthenticated, backoffice.beerPreview);
  app.post('/set-visibility/:beerId', authController.isAuthenticated, backoffice.setVisibility);

  app.get('/edit-beer', authController.isAuthenticated, backoffice.editBeer);
  app.post('/edit-beer', authController.isAuthenticated, backoffice.editBeer);

  app.get('/beerOKmodal', function(req,res) {
    res.render('views/backoffice/beerOKmodal', { title: 'OK' })
  });

  app.delete('/delete-beer/:beerId', authController.isAuthenticated, backoffice.deleteBeer);
  app.post('/undelete-beer/:beerId', authController.isAuthenticated, backoffice.undeleteBeer);

  app.post('/register-beer-image', authController.isAuthenticated, upload.single('file'), backoffice.registerBeerImage);
  app.get('/beer-image/:beerId', routes.beerImage);

  app.get('*', routes._404);

  // Start it up!
  this.start = function() {
    server = app.listen(app.get('port'), app.get('ip'), function() {
      console.log('\x1b[33m' + 'Running in '+ process.env.NODE_ENV + ' mode\x1b[0m');
      console.log('\x1b[32m✔\x1b[0m [%s] Express server listening at %s:%d', Date(Date.now()), app.get('ip'),app.get('port'));
    });
  };

  this.stop = function () {
    server.close(function() {
      console.log('Express server stopped successfully');
    });
  };
}

module.exports = Server;


text:
'use strict';

var mongoose = require('mongoose');
var path = require('path');
var Schema = mongoose.Schema;
var jqUploads = require(path.join(__dirname, '../..'));

var ApplicantSchema = new Schema({
  surname:  {type: String, required: true, index: true},
  forename: {type: String, index: true},
  photo:    {type: [new Schema(jqUploads.FileSchema)], form: {directive: 'fng-jq-upload-form', add: {sizeLimit: 50000000}}},
  status:   {type: String, default: 'Pending', enum: ['Pending', 'Rejected', 'Shortlist']}
});

var Applicant;
try {
  Applicant = mongoose.model('Applicant');
} catch (e) {
  Applicant = mongoose.model('Applicant', ApplicantSchema);
}

module.exports = Applicant;


text:
/*
 * Decompiled with CFR 0_119.
 */
package script.dataObjects;

import java.util.LinkedList;
import script.EvaluationError;
import script.InternalScriptError;
import script.LRfinalTokens.StructDefinition;
import script.LRhighTokens.DummyTypeDefinition;
import script.LRhighTokens.TypeDefinition;
import script.Tools;
import script.dataObjects.ArrayObject;
import script.dataObjects.BoolObject;
import script.dataObjects.DataObject;
import script.dataObjects.FloatObject;
import script.dataObjects.IntObject;
import script.dataObjects.NullObject;
import script.dataObjects.StringObject;

public class DataType {
    private types type;
    private DataType referencedType = null;
    private LinkedList<DataType> allowedContent = null;
    private TypeDefinition definition = null;
    public static DataType FLOAT = new DataType(types.FLOAT);
    public static DataType INT = new DataType(types.INT);
    public static DataType BOOL = new DataType(types.BOOL);
    public static DataType ARRAY = new DataType(types.ARRAY);
    public static DataType STRING = new DataType(types.STRING);
    private static /* synthetic */ int[] $SWITCH_TABLE$script$dataObjects$DataType$types;

    public LinkedList<DataType> getAllowedContent() {
        return this.allowedContent;
    }

    public DataType(LinkedList<DataType> cont) {
        this.allowedContent = cont;
        this.type = types.ARRAY;
    }

    public DataType(types t) {
        if (t == types.USER) {
            throw new Error("WTF---");
        }
        this.type = t;
    }

    public DataType(TypeDefinition t) throws InternalScriptError {
        if (t instanceof DummyTypeDefinition) {
            throw new InternalScriptError("The type " + t.getName() + " was declared extern, but no external definition was found!");
        }
        if (t == null) {
            throw new Error("Unable to create datatype from NULL TypdefStatement");
        }
        this.type = types.USER;
        this.definition = t;
    }

    public DataType(StructDefinition t) {
        if (t == null) {
            throw new Error("Unable to create datatype from NULL TypdefStatement");
        }
        this.type = types.USER;
        this.definition = t;
    }

    public static DataType getReferenceType(DataType t) {
        DataType result = new DataType(types.PTR);
        result.referencedType = t;
        return result;
    }

    public boolean isValidAsParameter() {
        if (this.type == types.VAR || this.type == types.VOID) {
            return false;
        }
        return true;
    }

    public String toString() {
        switch (DataType.$SWITCH_TABLE$script$dataObjects$DataType$types()[this.type.ordinal()]) {
            case 1: {
                return "bool";
            }
            case 2: {
                return "int";
            }
            case 3: {
                return "string";
            }
            case 4: {
                return "var";
            }
            case 5: {
                return "array" + (this.allowedContent != null ? Tools.listToString(this.allowedContent, "<", ">") : "");
            }
            case 6: {
                return "float";
            }
            case 7: {
                return "void";
            }
            case 9: {
                return "object";
            }
            case 8: {
                return this.referencedType + "*";
            }
            case 11: {
                return "none";
            }
            case 10: {
                return this.definition.getName();
            }
        }
        return "WTF11";
    }

    public DataObject getNewInstance() throws InternalScriptError, EvaluationError {
        switch (DataType.$SWITCH_TABLE$script$dataObjects$DataType$types()[this.type.ordinal()]) {
            case 1: {
                return BoolObject.FALSE;
            }
            case 2: {
                return new IntObject(0);
            }
            case 3: {
                return new StringObject("");
            }
            case 4: {
                throw new InternalScriptError("Cannot create VAR objects!");
            }
            case 5: {
                return new ArrayObject();
            }
            case 6: {
                return new FloatObject(0.0f);
            }
            case 7: {
                throw new InternalScriptError("cannot instanciate variables of type void");
            }
            case 8: {
                throw new InternalScriptError("cannot instanciate pointer variables with a constructor");
            }
            case 10: {
                return this.definition.getNewInstance();
            }
        }
        throw new InternalScriptError("cannot instanciate variables of type " + this);
    }

    public DataObject getDefaultInstance() throws InternalScriptError {
        switch (DataType.$SWITCH_TABLE$script$dataObjects$DataType$types()[this.type.ordinal()]) {
            case 1: {
                return BoolObject.FALSE;
            }
            case 2: {
                return new IntObject(0);
            }
            case 3: {
                return new StringObject("");
            }
            case 4: {
                return new NullObject(new DataType(types.VAR));
            }
            case 5: {
                return new NullObject(new DataType(types.ARRAY));
            }
            case 6: {
                return new FloatObject(0.0f);
            }
            case 7: {
                throw new InternalScriptError("cannot instanciate variables of type void");
            }
            case 8: {
                return new NullObject(this.referencedType);
            }
            case 10: {
                return this.definition.getDefaultInstance();
            }
        }
        throw new InternalScriptError("cannot instanciate variables of type " + this);
    }

    public boolean equals(Object o) {
        if (!(o instanceof DataType)) {
            return false;
        }
        DataType t = (DataType)o;
        if (t.type != this.type) {
            return false;
        }
        if (t.type == types.PTR) {
            return this.referencedType.equals(t.referencedType);
        }
        if (t.type == types.USER) {
            if (t.definition == this.definition) {
                return true;
            }
            return false;
        }
        if (t.type == types.ARRAY) {
            if (t.allowedContent == null) {
                if (this.allowedContent == null) {
                    return true;
                }
                return false;
            }
            if (this.allowedContent == null) {
                return false;
            }
            return t.allowedContent.equals(this.allowedContent);
        }
        return true;
    }

    public DataObject getNewInstance(DataObject initValue) throws InternalScriptError {
        return initValue.implicitCastTo(this);
    }

    public types getBasicType() {
        return this.type;
    }

    public DataType getReferencedType() {
        return this.referencedType;
    }

    public boolean isVoidPointer() {
        if (this.type == types.PTR) {
            return this.referencedType.containsVoid();
        }
        return false;
    }

    private boolean containsVoid() {
        if (this.type == types.PTR) {
            return this.referencedType.containsVoid();
        }
        if (this.type == types.VOID) {
            return true;
        }
        return false;
    }

    public boolean isDerivedFrom(DataType t) throws InternalScriptError {
        if (t.equals(this)) {
            return true;
        }
        if (this.getBasicType() == types.USER) {
            return this.definition.isDerivedFrom(t);
        }
        if (this.getBasicType() == types.ARRAY && t.getBasicType() == types.ARRAY) {
            return true;
        }
        return false;
    }

    public TypeDefinition getDefinition() {
        return this.definition;
    }

    static /* synthetic */ int[] $SWITCH_TABLE$script$dataObjects$DataType$types() {
        int[] arrn;
        int[] arrn2 = $SWITCH_TABLE$script$dataObjects$DataType$types;
        if (arrn2 != null) {
            return arrn2;
        }
        arrn = new int[types.values().length];
        try {
            arrn[types.ARRAY.ordinal()] = 5;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.BOOL.ordinal()] = 1;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.FLOAT.ordinal()] = 6;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.INT.ordinal()] = 2;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.NONE.ordinal()] = 11;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.OBJECT.ordinal()] = 9;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.PTR.ordinal()] = 8;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.STRING.ordinal()] = 3;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.USER.ordinal()] = 10;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.VAR.ordinal()] = 4;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        try {
            arrn[types.VOID.ordinal()] = 7;
        }
        catch (NoSuchFieldError noSuchFieldError) {}
        $SWITCH_TABLE$script$dataObjects$DataType$types = arrn;
        return $SWITCH_TABLE$script$dataObjects$DataType$types;
    }

    public static enum types {
        BOOL,
        INT,
        STRING,
        VAR,
        ARRAY,
        FLOAT,
        VOID,
        PTR,
        OBJECT,
        USER,
        NONE;

        private types(String string2, int n2) {
        }
    }

}


text:
<?xml version="1.0" ?>
<!DOCTYPE project [
        <!ENTITY properties SYSTEM "file:../../xmls/properties.xml">
        <!ENTITY paths  SYSTEM "file:../../xmls/path_refs.xml">
        <!ENTITY taskdefs SYSTEM "file:../../xmls/taskdefs.xml">
        <!ENTITY taskdefs_post_compile SYSTEM "file:../../xmls/taskdefs_post_compile.xml">
        <!ENTITY targets SYSTEM "file:../../xmls/targets.xml">
]>

<!-- ===================================================================
<description>
   Test/Sample Component file for Axis

Notes:
   This is a build file for use with the Jakarta Ant build tool.

Prerequisites:

   jakarta-ant from http://jakarta.apache.org

Build Instructions:
   To compile
        ant compile
   To execute
        ant run

Author:
  Matt Seibert mseibert@us.ibm.com

Copyright:
  Copyright (c) 2002-2003 Apache Software Foundation.
</description>
==================================================================== -->

<project default="compile">
<property name="axis.home" location="../.." />
<property name="componentName" value="samples/attachments" />

        &properties;
        &paths;
        &taskdefs;
        &taskdefs_post_compile;
	&targets;

<target name="clean"/>

<target name="copy" depends="setenv"/>

<target name="compile" depends="copy">
  <javac srcdir="${axis.home}" destdir="${build.dest}" debug="${debug}" nowarn="${nowarn}" source="${source}" fork="${javac.fork}">
    <classpath>
        <path refid="classpath"/>
    </classpath>
    <include name="samples/attachments/**/*.java" if="attachments.present"/>
    <exclude name="samples/**/*SMTP*.java" unless="smtp.present" />
    <exclude name="**/old/**/*.java" />
  </javac>
</target>

<target name="deploy"/>

<target name="run"/>

<target name="undeploy"/>

</project>


text:
<!--
    Ce fichier contient les directives runtime utilisées par .NET Native. Les valeurs par défaut conviennent à la plupart des
    développeurs. Toutefois, vous pouvez modifier ces paramètres pour changer le comportement de
    l'optimiseur .NET Native.

    Les directives runtime sont documentées sur https://go.microsoft.com/fwlink/?LinkID=391919

    Pour activer complètement la réflexion de App1.MyClass et de tous ses membres publics/privés
    <Type Name="App1.MyClass" Dynamic="Required All"/>

    Pour activer la création dynamique de l'instanciation spécifique de AppClass<T> sur System.Int32
    <TypeInstantiation Name="App1.AppClass" Arguments="System.Int32" Activate="Required Public" />

    Utilisation de la directive Namespace pour appliquer la stratégie de réflexion à tous les types d'un espace de noms particulier
    <Namespace Name="DataClasses.ViewModels" Serialize="All" />
-->

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
  <Application>
    <!--
      Un élément Assembly dont Name="*Application*" s'applique à tous les assemblys du
      package d'application. Les astérisques ne sont pas des caractères génériques.
    -->
    <Assembly Name="*Application*" Dynamic="Required All" />

    <!-- Ajoutez ici les directives runtime spécifiques à votre application. -->

  </Application>
</Directives>


text:
<title>Henrique Cursos</title>
<link href="estilo.css" rel="stylesheet" type="text/css">


text:
namespace chromeos {

struct AudioDevice;

// Interface that handles audio preference related work, reads and writes
// audio preferences, and notifies AudioPrefObserver for audio preference
// changes.
class CHROMEOS_EXPORT AudioDevicesPrefHandler
    : public base::RefCountedThreadSafe<AudioDevicesPrefHandler> {
 public:
  // Integer because C++ does not allow static const double in header files.
  static const int kDefaultOutputVolumePercent = 75;
  static const int kDefaultHdmiOutputVolumePercent = 100;

  // Gets the audio output volume value from prefs for a device. Since we can
  // only have either a gain or a volume for a device (depending on whether it
  // is input or output), we don't really care which value it is.
  virtual double GetOutputVolumeValue(const AudioDevice* device) = 0;
  virtual double GetInputGainValue(const AudioDevice* device) = 0;
  // Sets the audio volume or gain value to prefs for a device.
  virtual void SetVolumeGainValue(const AudioDevice& device, double value) = 0;

  // Reads the audio mute value from prefs for a device.
  virtual bool GetMuteValue(const AudioDevice& device) = 0;
  // Sets the audio mute value to prefs for a device.
  virtual void SetMuteValue(const AudioDevice& device, bool mute_on) = 0;

  // Sets the device active state in prefs.
  // Note: |activate_by_user| indicates whether |device| is set to active
  // by user or by priority, and it only matters when |active| is true.
  virtual void SetDeviceActive(const AudioDevice& device,
                               bool active,
                               bool activate_by_user) = 0;
  // Returns false if it fails to get device active state from prefs.
  // Otherwise, returns true, pass the active state data in |*active|
  // and |*activate_by_user|.
  // Note: |*activate_by_user| only matters when |*active| is true.
  virtual bool GetDeviceActive(const AudioDevice& device,
                               bool* active,
                               bool* activate_by_user) = 0;

  // Reads the audio output allowed value from prefs.
  virtual bool GetAudioOutputAllowedValue() = 0;

  // Adds an audio preference observer.
  virtual void AddAudioPrefObserver(AudioPrefObserver* observer) = 0;
  // Removes an audio preference observer.
  virtual void RemoveAudioPrefObserver(AudioPrefObserver* observer) = 0;

 protected:
  virtual ~AudioDevicesPrefHandler() {}

 private:
  friend class base::RefCountedThreadSafe<AudioDevicesPrefHandler>;
};

}  // namespace chromeos

#endif  // CHROMEOS_AUDIO_AUDIO_DEVICES_PREF_HANDLER_H_


text:
<?php

namespace PHP_CodeSniffer\Standards\Generic\Sniffs\PHP;

use PHP_CodeSniffer\Sniffs\Sniff;
use PHP_CodeSniffer\Files\File;

class LowerCaseConstantSniff implements Sniff
{

    /**
     * A list of tokenizers this sniff supports.
     *
     * @var array
     */
    public $supportedTokenizers = array(
                                   'PHP',
                                   'JS',
                                  );

    /**
     * Returns an array of tokens this test wants to listen for.
     *
     * @return array
     */
    public function register()
    {
        return array(
                T_TRUE,
                T_FALSE,
                T_NULL,
               );

    }//end register()

    /**
     * Processes this sniff, when one of its tokens is encountered.
     *
     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
     * @param int                         $stackPtr  The position of the current token in the
     *                                               stack passed in $tokens.
     *
     * @return void
     */
    public function process(File $phpcsFile, $stackPtr)
    {
        $tokens   = $phpcsFile->getTokens();
        $keyword  = $tokens[$stackPtr]['content'];
        $expected = strtolower($keyword);
        if ($keyword !== $expected) {
            if ($keyword === strtoupper($keyword)) {
                $phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'upper');
            } else {
                $phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'mixed');
            }

            $error = 'TRUE, FALSE and NULL must be lowercase; expected "%s" but found "%s"';
            $data  = array(
                      $expected,
                      $keyword,
                     );

            $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found', $data);
            if ($fix === true) {
                $phpcsFile->fixer->replaceToken($stackPtr, $expected);
            }
        } else {
            $phpcsFile->recordMetric($stackPtr, 'PHP constant case', 'lower');
        }

    }//end process()

}//end class


text:
package de.marhan.craps.game.round;

import de.marhan.craps.Die;
import de.marhan.craps.Player;
import de.marhan.craps.util.DomainObject;

import java.util.Set;

import static java.lang.String.format;

public class ComeOutRound extends DomainObject implements Round {

    private final Set<Die> dice;
    private int sum;
    private ComeOutResult comeOutResult;

    public ComeOutRound(Set<Die> dice) {
        this.dice = dice;
    }

    @Override
    public int getSum() {
        return sum;
    }

    public ComeOutResult getComeOutResult() {
        return comeOutResult;
    }

    public Round play(Player shooter) {
        this.sum = shooter.rollDice(this.dice);
        this.comeOutResult = ComeOutResult.determine(sum);
        return this;
    }

    @Override
    public String buildMessage() {
        return "Shooter" + format(" come-out with %s (%s)", sum, comeOutResult);
    }

}


text:
package com.app.mobilesafe;

import android.app.ActivityManager;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.Color;
import android.os.Bundle;
import android.text.format.Formatter;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.PopupMenu;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.app.mobilesafe.domain.TaskInfo;
import com.app.mobilesafe.engine.TaskInfoProvider;
import com.app.mobilesafe.utils.SystemInfoUtils;

import java.util.ArrayList;
import java.util.List;

public class TaskManagerActivity extends BaseActivity {

	private TextView tv_process_count;
	private TextView tv_mem_info;

	private LinearLayout ll_loading;
	private ListView lv_task_manager;
	private List<TaskInfo> taskInfos;
	private List<TaskInfo> userTaskInfos;
	private List<TaskInfo> sysTaskInfos;
	private MyAapater adapter;
	private TextView tv_task_status;

	private Button btn_menu;

	private int processCount;
	private long availMem;
	private SharedPreferences sp;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_taskmanager);
		sp = getSharedPreferences("config", MODE_PRIVATE);

		tv_process_count = (TextView) findViewById(R.id.tv_process_count);
		tv_mem_info = (TextView) findViewById(R.id.tv_mem_info);
		tv_task_status = (TextView) findViewById(R.id.tv_show_task_count);
		btn_menu = (Button) findViewById(R.id.btn_menu);

		btn_menu.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View arg0) {
				showPopMenu(btn_menu);
			}
		});

		setTitle();

		ll_loading = (LinearLayout) findViewById(R.id.ll_loading);
		lv_task_manager = (ListView) findViewById(R.id.lv_tasks_manager);
		adapter = new MyAapater();

		fillData();

		lv_task_manager.setOnScrollListener(new OnScrollListener() {

			@Override
			public void onScrollStateChanged(AbsListView view, int scrollState) {
			}

			@Override
			public void onScroll(AbsListView view, int firstVisibleItem,
					int visibleItemCount, int totalItemCount) {
				if (userTaskInfos != null && sysTaskInfos != null) {
					if (firstVisibleItem >= userTaskInfos.size() + 1) {
						tv_task_status.setText("系统进程( " + sysTaskInfos.size() + " )");
					} else {
						tv_task_status.setText("用户进程( " + userTaskInfos.size() + " )");
					}
				}
			}
		});

		lv_task_manager.setOnItemClickListener(new OnItemClickListener() {

			@Override
			public void onItemClick(AdapterView<?> parent, View view, int position,
					long id) {
				TaskInfo taskInfo;
				if (position == 0) {
	                return;
	            } else if (position == (userTaskInfos.size() + 1)) {
	                return;
	            } else if (position <= userTaskInfos.size()) { // 用户程序
	                int newPositon = position - 1;
	                taskInfo = userTaskInfos.get(newPositon);
	            } else { // 系统程序
	                int newPosition = position - userTaskInfos.size() - 2;
	                taskInfo = sysTaskInfos.get(newPosition);
	            }
				//屏蔽自身进程
				if (taskInfo.getPackName().equals(getPackageName())) {
					return;
				}
				ViewHolder holder = (ViewHolder) view.getTag();
				if (taskInfo.isChecked()) {
					taskInfo.setChecked(false);
					holder.cb_status.setChecked(false);
				} else {
					taskInfo.setChecked(true);
					holder.cb_status.setChecked(true);
				}
			}
		});
	}

	protected void showPopMenu(View view) {
		 PopupMenu popupMenu = new PopupMenu(this, view);
		 // menu布局
		 popupMenu.getMenuInflater().inflate(R.menu.menu_main, popupMenu.getMenu());
		 // menu的item点击事件
		 popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
		  @Override
		  public boolean onMenuItemClick(MenuItem item) {

		  switch (item.getItemId()) {
		case R.id.action_select:
			selectAllTask();
			break;
		case R.id.action_inselect:
			unSelectAllTask();
			break;
		case R.id.action_clean:
			killAllTask();
			break;
		case R.id.action_setting:
			enterSetting();
			break;
		default:
			break;
		}
		  return false;
		  }
		 });
		 // PopupMenu关闭事件
		 popupMenu.setOnDismissListener(new PopupMenu.OnDismissListener() {
		  @Override
		  public void onDismiss(PopupMenu menu) {
			  menu.dismiss();
		  }
		 });
		 popupMenu.show();
	}

	private void setTitle() {
		processCount = SystemInfoUtils.getRunningProcessCount(TaskManagerActivity.this);
		tv_process_count.setText("运行中的进程( " + processCount + " )");
		availMem = SystemInfoUtils.getAvailMem(TaskManagerActivity.this);
		long totalMem = SystemInfoUtils.getTotalMem(TaskManagerActivity.this);
		tv_mem_info.setText("剩余/总内存( " + Formatter.formatFileSize(TaskManagerActivity.this, availMem) +
				"/" + Formatter.formatFileSize(TaskManagerActivity.this, totalMem) + " )");
	}

	private void fillData() {
		ll_loading.setVisibility(View.VISIBLE);
		new Thread(){

			public void run() {
				taskInfos = TaskInfoProvider.getTaskInfos(TaskManagerActivity.this);
				userTaskInfos = new ArrayList<TaskInfo>();
				sysTaskInfos = new ArrayList<TaskInfo>();

				for (TaskInfo info : taskInfos) {
					if (info.isUserTask()) {
						userTaskInfos.add(info);
					} else {
						sysTaskInfos.add(info);
					}
				}
				runOnUiThread(new Runnable() {

					@Override
					public void run() {
						ll_loading.setVisibility(View.GONE);
						lv_task_manager.setAdapter(adapter);
						setTitle();
					}
				});
			};
		}.start();
	}

	private class MyAapater extends BaseAdapter {

        @Override
        public int getCount() {
        	if (sp.getBoolean("showsystem", false)) {
        		return taskInfos.size() + 2;
        	} else {
        		return userTaskInfos.size() + 1;
        	}
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            final TaskInfo taskInfo;

            if (position == 0) {
                TextView tv = new TextView(TaskManagerActivity.this);
                tv.setTextColor(Color.WHITE);
                tv.setBackgroundColor(Color.parseColor("#77212121"));
                tv.setText("用户程序 ( " + userTaskInfos.size() + " )");
                return tv;
            } else if (position == (userTaskInfos.size() + 1)) {
                TextView tv = new TextView(TaskManagerActivity.this);
                tv.setTextColor(Color.WHITE);
                tv.setBackgroundColor(Color.parseColor("#77212121"));
                tv.setText("系统程序 ( " + sysTaskInfos.size() + " )");
                return tv;
            } else if (position <= userTaskInfos.size()) { // 用户程序
                int newPositon = position - 1;
                taskInfo = userTaskInfos.get(newPositon);
            } else { // 系统程序
                int newPosition = position - userTaskInfos.size() - 2;
                taskInfo = sysTaskInfos.get(newPosition);
            }

            View view;
            final ViewHolder holder;

            if (convertView != null && convertView instanceof RelativeLayout) {
                view = convertView;
                holder = (ViewHolder) view.getTag();
            } else {
                view = View.inflate(TaskManagerActivity.this,
                        R.layout.list_item_taskinfo, null);
                holder = new ViewHolder();
                holder.tv_name = (TextView) view.findViewById(R.id.tv_task_name);
                holder.tv_size = (TextView) view
                        .findViewById(R.id.tv_task_size);
                holder.iv_icon = (ImageView) view
                        .findViewById(R.id.iv_task_icon);
                holder.cb_status = (CheckBox) view.findViewById(R.id.cb_task_isdelete);
                view.setTag(holder);
            }
            holder.iv_icon.setImageDrawable(taskInfo.getIcon());
            holder.tv_name.setText(taskInfo.getName());
            holder.tv_size.setText("内存占用:" + Formatter.formatFileSize(TaskManagerActivity.this, taskInfo.getMemSize()));
            holder.cb_status.setChecked(taskInfo.isChecked());
            if (getPackageName().equals(taskInfo.getPackName())) {
            	holder.cb_status.setVisibility(View.INVISIBLE);
			} else {
				holder.cb_status.setVisibility(View.VISIBLE);
			}

            return view;
        }

        @Override
        public Object getItem(int arg0) {
            return null;
        }

        @Override
        public long getItemId(int position) {
            return 0;
        }

    }

    static class ViewHolder {
        TextView tv_name;
        TextView tv_size;
        ImageView iv_icon;
        CheckBox cb_status;
    }

	/**
	 * 选中全部
	 */
	private void selectAllTask() {
		List<TaskInfo> tmpInfos;
		if (sp.getBoolean("showsystem", false)) {
			tmpInfos = taskInfos;
		} else {
			tmpInfos = userTaskInfos;
		}
		for (TaskInfo info : tmpInfos) {
			if (getPackageName().equals(info.getPackName())) {
				continue;
			}
			info.setChecked(true);
		}
		adapter.notifyDataSetChanged();
	}

	/**
	 * 反选
	 */
	private void unSelectAllTask() {
		List<TaskInfo> tmpInfos;
		if (sp.getBoolean("showsystem", false)) {
			tmpInfos = taskInfos;
		} else {
			tmpInfos = userTaskInfos;
		}

		for (TaskInfo info : tmpInfos) {
			if (getPackageName().equals(info.getPackName())) {
				continue;
			}
			info.setChecked(!info.isChecked());
		}
		adapter.notifyDataSetChanged();
	}

	/**
	 * 一键清理
	 */
	private void killAllTask() {
		List<TaskInfo> tmpInfos;
		if (sp.getBoolean("showsystem", false)) {
			tmpInfos = taskInfos;
		} else {
			tmpInfos = userTaskInfos;
		}

		ActivityManager am = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
		int count = 0;
		int releaseMem = 0;
		List<TaskInfo> killedTaskInfos = new ArrayList<TaskInfo>();
		for (TaskInfo info : tmpInfos) {
			if (info.isChecked()) {
				am.killBackgroundProcesses(info.getPackName());
				if (info.isUserTask()) {
					userTaskInfos.remove(info);
				} else {
					sysTaskInfos.remove(info);
				}
				killedTaskInfos.add(info);
				count++;
				releaseMem += info.getMemSize();
			}
		}
		tmpInfos.removeAll(killedTaskInfos);

		adapter.notifyDataSetChanged();
		Toast.makeText(TaskManagerActivity.this,
				"结束" + count + "个进程,释放" + Formatter.formatFileSize(TaskManagerActivity.this, releaseMem) + "内存",
				Toast.LENGTH_SHORT).show();
		//更新title
		processCount -= count;
		availMem += releaseMem;
		tv_process_count.setText("运行中的进程( " + processCount + " )");
		long totalMem = SystemInfoUtils.getTotalMem(TaskManagerActivity.this);
		tv_mem_info.setText("剩余/总内存( " + Formatter.formatFileSize(TaskManagerActivity.this, availMem) +
				"/" + Formatter.formatFileSize(TaskManagerActivity.this, totalMem) + " )");

	}

	/**
	 * 进入设置
	 */
	private void enterSetting() {
		Intent intent = new Intent(TaskManagerActivity.this, TaskSettingAcitivity.class);
		startActivityForResult(intent, 0);
	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		adapter.notifyDataSetChanged();
		super.onActivityResult(requestCode, resultCode, data);
	}
}


text:
#include <netstd/mutex.h>
#include <pthread.h>
#include <stdlib.h>

net_mutex_t net_mutex_new(){
	pthread_mutex_t* mtx = malloc(sizeof(pthread_mutex_t));
	if(!mtx) return NET_MUTEX_INVALID;
	if(pthread_mutex_init(mtx,0)) return mtx;
	free(mtx);
	return NET_MUTEX_INVALID;
}

void net_mutex_lock(net_mutex_t m){
	pthread_mutex_lock((pthread_mutex_t*)m);
}

int net_mutex_trylock(net_mutex_t m){
	return pthread_mutex_trylock((pthread_mutex_t*)m);
}

void net_mutex_unlock(net_mutex_t m){
	pthread_mutex_unlock((pthread_mutex_t*)m);
}


text:
#ifndef _PASSENGER_SPAWNING_KIT_FACTORY_H_
#define _PASSENGER_SPAWNING_KIT_FACTORY_H_

#include <SpawningKit/Spawner.h>
#include <SpawningKit/SmartSpawner.h>
#include <SpawningKit/DirectSpawner.h>
#include <SpawningKit/DummySpawner.h>

namespace Passenger {
namespace SpawningKit {

using namespace std;
using namespace boost;
using namespace oxt;

class Factory {
private:
	boost::mutex syncher;
	ConfigPtr config;
	DummySpawnerPtr dummySpawner;

	SpawnerPtr tryCreateSmartSpawner(const Options &options) {
		string dir = config->resourceLocator->getHelperScriptsDir();
		vector<string> preloaderCommand;
		if (options.appType == "rack") {
			preloaderCommand.push_back(options.ruby);
			preloaderCommand.push_back(dir + "/rack-preloader.rb");
		} else {
			return SpawnerPtr();
		}
		return boost::make_shared<SmartSpawner>(preloaderCommand,
			options, config);
	}

public:
	Factory(const ConfigPtr &_config)
		: config(_config)
		{ }

	virtual ~Factory() { }

	virtual SpawnerPtr create(const Options &options) {
		if (options.spawnMethod == "smart" || options.spawnMethod == "smart-lv2") {
			SpawnerPtr spawner = tryCreateSmartSpawner(options);
			if (spawner == NULL) {
				spawner = boost::make_shared<DirectSpawner>(config);
			}
			return spawner;
		} else if (options.spawnMethod == "direct" || options.spawnMethod == "conservative") {
			boost::shared_ptr<DirectSpawner> spawner = boost::make_shared<DirectSpawner>(
				config);
			return spawner;
		} else if (options.spawnMethod == "dummy") {
			syscalls::usleep(config->spawnerCreationSleepTime);
			return getDummySpawner();
		} else {
			throw ArgumentException("Unknown spawn method '" + options.spawnMethod + "'");
		}
	}

	/**
	 * SpawnerFactory always returns the same DummyFactory object upon
	 * creating a dummy spawner. This allows unit tests to easily
	 * set debugging options on the spawner.
	 */
	DummySpawnerPtr getDummySpawner() {
		boost::lock_guard<boost::mutex> l(syncher);
		if (dummySpawner == NULL) {
			dummySpawner = boost::make_shared<DummySpawner>(config);
		}
		return dummySpawner;
	}

	/**
	 * All created Spawner objects share the same Config object.
	 */
	const ConfigPtr &getConfig() const {
		return config;
	}
};

typedef boost::shared_ptr<Factory> FactoryPtr;

} // namespace SpawningKit
} // namespace Passenger

#endif /* _PASSENGER_SPAWNING_KIT_FACTORY_H_ */


text:
using System;
using System.Collections.Generic;
using System.Reactive.Linq;
using System.Reactive.Threading.Tasks;
using MS.Core;

namespace System.Globalization
{
    public static class __DateTimeFormatInfo
    {
        public static IObservable<System.Globalization.DateTimeFormatInfo> GetInstance(
            IObservable<System.IFormatProvider> provider)
        {
            return Observable.Select(provider,
                (providerLambda) => System.Globalization.DateTimeFormatInfo.GetInstance(providerLambda));
        }

        public static IObservable<System.Object> GetFormat(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.Type> formatType)
        {
            return Observable.Zip(DateTimeFormatInfoValue, formatType,
                (DateTimeFormatInfoValueLambda, formatTypeLambda) =>
                    DateTimeFormatInfoValueLambda.GetFormat(formatTypeLambda));
        }

        public static IObservable<System.Object> Clone(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.Clone());
        }

        public static IObservable<System.Int32> GetEra(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> eraName)
        {
            return Observable.Zip(DateTimeFormatInfoValue, eraName,
                (DateTimeFormatInfoValueLambda, eraNameLambda) => DateTimeFormatInfoValueLambda.GetEra(eraNameLambda));
        }

        public static IObservable<System.String> GetEraName(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.Int32> era)
        {
            return Observable.Zip(DateTimeFormatInfoValue, era,
                (DateTimeFormatInfoValueLambda, eraLambda) => DateTimeFormatInfoValueLambda.GetEraName(eraLambda));
        }

        public static IObservable<System.String> GetAbbreviatedEraName(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.Int32> era)
        {
            return Observable.Zip(DateTimeFormatInfoValue, era,
                (DateTimeFormatInfoValueLambda, eraLambda) =>
                    DateTimeFormatInfoValueLambda.GetAbbreviatedEraName(eraLambda));
        }

        public static IObservable<System.String> GetAbbreviatedDayName(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.DayOfWeek> dayofweek)
        {
            return Observable.Zip(DateTimeFormatInfoValue, dayofweek,
                (DateTimeFormatInfoValueLambda, dayofweekLambda) =>
                    DateTimeFormatInfoValueLambda.GetAbbreviatedDayName(dayofweekLambda));
        }

        public static IObservable<System.String> GetShortestDayName(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.DayOfWeek> dayOfWeek)
        {
            return Observable.Zip(DateTimeFormatInfoValue, dayOfWeek,
                (DateTimeFormatInfoValueLambda, dayOfWeekLambda) =>
                    DateTimeFormatInfoValueLambda.GetShortestDayName(dayOfWeekLambda));
        }

        public static IObservable<System.String[]> GetAllDateTimePatterns(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.GetAllDateTimePatterns());
        }

        public static IObservable<System.String[]> GetAllDateTimePatterns(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.Char> format)
        {
            return Observable.Zip(DateTimeFormatInfoValue, format,
                (DateTimeFormatInfoValueLambda, formatLambda) =>
                    DateTimeFormatInfoValueLambda.GetAllDateTimePatterns(formatLambda));
        }

        public static IObservable<System.String> GetDayName(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.DayOfWeek> dayofweek)
        {
            return Observable.Zip(DateTimeFormatInfoValue, dayofweek,
                (DateTimeFormatInfoValueLambda, dayofweekLambda) =>
                    DateTimeFormatInfoValueLambda.GetDayName(dayofweekLambda));
        }

        public static IObservable<System.String> GetAbbreviatedMonthName(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.Int32> month)
        {
            return Observable.Zip(DateTimeFormatInfoValue, month,
                (DateTimeFormatInfoValueLambda, monthLambda) =>
                    DateTimeFormatInfoValueLambda.GetAbbreviatedMonthName(monthLambda));
        }

        public static IObservable<System.String> GetMonthName(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.Int32> month)
        {
            return Observable.Zip(DateTimeFormatInfoValue, month,
                (DateTimeFormatInfoValueLambda, monthLambda) => DateTimeFormatInfoValueLambda.GetMonthName(monthLambda));
        }

        public static IObservable<System.Globalization.DateTimeFormatInfo> ReadOnly(
            IObservable<System.Globalization.DateTimeFormatInfo> dtfi)
        {
            return Observable.Select(dtfi, (dtfiLambda) => System.Globalization.DateTimeFormatInfo.ReadOnly(dtfiLambda));
        }

        public static IObservable<System.Reactive.Unit> SetAllDateTimePatterns(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String[]> patterns, IObservable<System.Char> format)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, patterns, format,
                (DateTimeFormatInfoValueLambda, patternsLambda, formatLambda) =>
                    DateTimeFormatInfoValueLambda.SetAllDateTimePatterns(patternsLambda, formatLambda));
        }

        public static IObservable<System.Globalization.DateTimeFormatInfo> get_InvariantInfo()
        {
            return ObservableExt.Factory(() => System.Globalization.DateTimeFormatInfo.InvariantInfo);
        }

        public static IObservable<System.Globalization.DateTimeFormatInfo> get_CurrentInfo()
        {
            return ObservableExt.Factory(() => System.Globalization.DateTimeFormatInfo.CurrentInfo);
        }

        public static IObservable<System.String> get_AMDesignator(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.AMDesignator);
        }

        public static IObservable<System.Globalization.Calendar> get_Calendar(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.Calendar);
        }

        public static IObservable<System.String> get_DateSeparator(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.DateSeparator);
        }

        public static IObservable<System.DayOfWeek> get_FirstDayOfWeek(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.FirstDayOfWeek);
        }

        public static IObservable<System.Globalization.CalendarWeekRule> get_CalendarWeekRule(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.CalendarWeekRule);
        }

        public static IObservable<System.String> get_FullDateTimePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.FullDateTimePattern);
        }

        public static IObservable<System.String> get_LongDatePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.LongDatePattern);
        }

        public static IObservable<System.String> get_LongTimePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.LongTimePattern);
        }

        public static IObservable<System.String> get_MonthDayPattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.MonthDayPattern);
        }

        public static IObservable<System.String> get_PMDesignator(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.PMDesignator);
        }

        public static IObservable<System.String> get_RFC1123Pattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.RFC1123Pattern);
        }

        public static IObservable<System.String> get_ShortDatePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.ShortDatePattern);
        }

        public static IObservable<System.String> get_ShortTimePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.ShortTimePattern);
        }

        public static IObservable<System.String> get_SortableDateTimePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.SortableDateTimePattern);
        }

        public static IObservable<System.String> get_TimeSeparator(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.TimeSeparator);
        }

        public static IObservable<System.String> get_UniversalSortableDateTimePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.UniversalSortableDateTimePattern);
        }

        public static IObservable<System.String> get_YearMonthPattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.YearMonthPattern);
        }

        public static IObservable<System.String[]> get_AbbreviatedDayNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.AbbreviatedDayNames);
        }

        public static IObservable<System.String[]> get_ShortestDayNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.ShortestDayNames);
        }

        public static IObservable<System.String[]> get_DayNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.DayNames);
        }

        public static IObservable<System.String[]> get_AbbreviatedMonthNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.AbbreviatedMonthNames);
        }

        public static IObservable<System.String[]> get_MonthNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.MonthNames);
        }

        public static IObservable<System.Boolean> get_IsReadOnly(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.IsReadOnly);
        }

        public static IObservable<System.String> get_NativeCalendarName(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.NativeCalendarName);
        }

        public static IObservable<System.String[]> get_AbbreviatedMonthGenitiveNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.AbbreviatedMonthGenitiveNames);
        }

        public static IObservable<System.String[]> get_MonthGenitiveNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue)
        {
            return Observable.Select(DateTimeFormatInfoValue,
                (DateTimeFormatInfoValueLambda) => DateTimeFormatInfoValueLambda.MonthGenitiveNames);
        }

        public static IObservable<System.Reactive.Unit> set_AMDesignator(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) => DateTimeFormatInfoValueLambda.AMDesignator = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_Calendar(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.Globalization.Calendar> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) => DateTimeFormatInfoValueLambda.Calendar = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_DateSeparator(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.DateSeparator = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_FirstDayOfWeek(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.DayOfWeek> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.FirstDayOfWeek = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_CalendarWeekRule(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.Globalization.CalendarWeekRule> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.CalendarWeekRule = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_FullDateTimePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.FullDateTimePattern = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_LongDatePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.LongDatePattern = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_LongTimePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.LongTimePattern = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_MonthDayPattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.MonthDayPattern = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_PMDesignator(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) => DateTimeFormatInfoValueLambda.PMDesignator = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_ShortDatePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.ShortDatePattern = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_ShortTimePattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.ShortTimePattern = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_TimeSeparator(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.TimeSeparator = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_YearMonthPattern(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.YearMonthPattern = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_AbbreviatedDayNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String[]> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.AbbreviatedDayNames = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_ShortestDayNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String[]> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.ShortestDayNames = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_DayNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String[]> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) => DateTimeFormatInfoValueLambda.DayNames = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_AbbreviatedMonthNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String[]> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.AbbreviatedMonthNames = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_MonthNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String[]> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) => DateTimeFormatInfoValueLambda.MonthNames = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_AbbreviatedMonthGenitiveNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String[]> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.AbbreviatedMonthGenitiveNames = valueLambda);
        }

        public static IObservable<System.Reactive.Unit> set_MonthGenitiveNames(
            this IObservable<System.Globalization.DateTimeFormatInfo> DateTimeFormatInfoValue,
            IObservable<System.String[]> value)
        {
            return ObservableExt.ZipExecute(DateTimeFormatInfoValue, value,
                (DateTimeFormatInfoValueLambda, valueLambda) =>
                    DateTimeFormatInfoValueLambda.MonthGenitiveNames = valueLambda);
        }
    }
}