text:
function meshlight2ScFile(vertices,faces,lightName,emitColor,radiance,scFile)
%fuction to write vertices to sunflow mesh in sc file
%vertices,faces,fid is file ID,shader
numberOfVertices=length(vertices);
numberOfFaces=length(faces);
%verticesStr=num2str(vertices);
facesStr=num2str(faces);

meshLightData1=strvcat('light {',...
                       '  type meshlight' ,...
                      ['  name ' lightName]);
[m,n]=size(meshLightData1);

for count=1:m
    fprintf(scFile,'%s\n',meshLightData1(count,:));
end

fprintf(scFile,'  emit %s\n',num2str(emitColor));
fprintf(scFile,'  radiance %s\n',num2str(radiance));
fprintf(scFile,'  samples 16\n');
fprintf(scFile,['  points ' num2str(numberOfVertices) '\n']);
for count=1:numberOfVertices
    fprintf(scFile,'      %8.5f      %8.5f     %8.5f\n',vertices(count,:));
end

meshLightData2=['  triangles ' num2str(numberOfFaces)];
fprintf(scFile,'%s\n',meshLightData2);

for count=1:numberOfFaces
    fprintf(scFile,'      %s\n',facesStr(count,:));
end

fprintf(scFile,'} \n');


text:
<!DOCTYPE html>

    <meta charset="UTF-8">
    <title>Home</title>

Doge social network

Home

Profile

Friends

Welcome to the Doge Social Network

Here you can find friends or talk strangers.

The Doge Social Network does not take any responsibility for the information found.

redpajama_set_name: RedPajamaGithub


text:
# Chai Assertions for Promises

**Chai as Promised** extends [Chai][chai] with a fluent language for asserting facts about [promises][presentation].

Instead of manually wiring up your expectations to a promise's fulfilled and rejected handlers:

```javascript
doSomethingAsync().then(
    function (result) {
        result.should.equal("foo");
        done();
    },
    function (err) {
       done(err);
    }
);
```

you can write code that expresses what you really mean:

```javascript
return doSomethingAsync().should.eventually.equal("foo");
```

or if you have a testing framework that doesn't allow returning promises to signal asynchronous test completion, then
you can use the following workaround:

```javascript
doSomethingAsync().should.eventually.equal("foo").notify(done);
```

## How to Use

### `should`/`expect` Interface

The most powerful extension provided by Chai as Promised is the `eventually` property. With it, you can transform any
existing Chai assertion into one that acts on a promise:

```javascript
(2 + 2).should.equal(4);

// becomes
return Promise.resolve(2 + 2).should.eventually.equal(4);

expect({ foo: "bar" }).to.have.property("foo");

// becomes
return expect(Promise.resolve({ foo: "bar" })).to.eventually.have.property("foo");
```

There are also a few promise-specific extensions (with the usual `expect` equivalents also available):

```javascript
return promise.should.be.fulfilled;
return promise.should.eventually.deep.equal("foo");
return promise.should.become("foo"); // same as `.eventually.deep.equal`
return promise.should.be.rejected;
return promise.should.be.rejectedWith(Error); // other variants of Chai's `throw` assertion work too.
```

### `assert` Interface

As with the `should`/`expect` interface, Chai as Promised provides an `eventually` extender to `chai.assert`, allowing
any existing Chai assertion to be used on a promise:

```javascript
assert.equal(2 + 2, 4, "This had better be true");

// becomes
return assert.eventually.equal(Promise.resolve(2 + 2), 4, "This had better be true, eventually");
```

And there are, of course, promise-specific extensions:

```javascript
return assert.isFulfilled(promise, "optional message");

return assert.becomes(promise, "foo", "optional message");
return assert.doesNotBecome(promise, "foo", "optional message");

return assert.isRejected(promise, "optional message");
return assert.isRejected(promise, Error, "optional message");
return assert.isRejected(promise, /error message matcher/, "optional message");
```

### Progress Callbacks

Chai as Promised does not have any intrinsic support for testing promise progress callbacks. The properties you would
want to test are probably much better suited to a library like [Sinon.JS][sinon], perhaps in conjunction with
[Sinon–Chai][sinon-chai]:

```javascript
var progressSpy = sinon.spy();

return promise.then(null, null, progressSpy).then(function () {
    progressSpy.should.have.been.calledWith("33%");
    progressSpy.should.have.been.calledWith("67%");
    progressSpy.should.have.been.calledThrice;
});
```

### Customizing Output Promises

By default, the promises returned by Chai as Promised's assertions are regular Chai assertion objects, extended with
a single `then` method derived from the input promise. To change this behavior, for instance to output a promise with
more useful sugar methods such as are found in most promise libraries, you can override
`chaiAsPromised.transferPromiseness`. Here's an example that transfer's Q's `finally` and `done` methods:

```js
chaiAsPromised.transferPromiseness = function (assertion, promise) {
    assertion.then = promise.then.bind(promise); // this is all you get by default
    assertion.finally = promise.finally.bind(promise);
    assertion.done = promise.done.bind(promise);
};
```

### Transforming Arguments to the Asserters

Another advanced customization hook Chai as Promised allows is if you want to transform the arguments to the
asserters, possibly asynchronously. Here is a toy example:

```js
chaiAsPromised.transformAsserterArgs = function (args) {
    return args.map(function (x) { return x + 1; });
}

Promise.resolve(2).should.eventually.equal(2); // will now fail!
Promise.resolve(2).should.eventually.equal(3); // will now pass!
```

The transform can even be asynchronous, returning a promise for an array instead of an array directly. An example
of that might be using `Promise.all` so that an array of promises becomes a promise for an array. If you do that,
then you can compare promises against other promises using the asserters:

```js
// This will normally fail, since within() only works on numbers.
Promise.resolve(2).should.eventually.be.within(Promise.resolve(1), Promise.resolve(6));

chaiAsPromised.transformAsserterArgs = function (args) {
    return Promise.all(args);
};

// But now it will pass, since we transformed the array of promises for numbers into
// (a promise for) an array of numbers
Promise.resolve(2).should.eventually.be.within(Promise.resolve(1), Promise.resolve(6));
```

### Compatibility

Chai as Promised is compatible with all promises following the [Promises/A+ specification][spec]. Notably, jQuery's
so-called "promises" are not up to spec, and Chai as Promised will not work with them. In particular, Chai as Promised
makes extensive use of the standard [transformation behavior][] of `then`, which jQuery does not support.

### Working with Non-Promise–Friendly Test Runners

Some test runners (e.g. Jasmine, QUnit, or tap/tape) do not have the ability to use the returned promise to signal
asynchronous test completion. If possible, I'd recommend switching to ones that do, such as [Mocha][mocha-promises],
[Buster][buster-promises], or [blue-tape][]. But if that's not an option, Chai as Promised still has you covered. As
long as your test framework takes a callback indicating when the asynchronous test run is over, Chai as Promised can
adapt to that situation with its `notify` method, like so:

```javascript
it("should be fulfilled", function (done) {
    promise.should.be.fulfilled.and.notify(done);
});

it("should be rejected", function (done) {
    otherPromise.should.be.rejected.and.notify(done);
});
```

In these examples, if the conditions are not met, the test runner will receive an error of the form `"expected promise
to be fulfilled but it was rejected with [Error: error message]"`, or `"expected promise to be rejected but it was
fulfilled."`

There's another form of `notify` which is useful in certain situations, like doing assertions after a promise is
complete. For example:

```javascript
it("should change the state", function (done) {
    otherState.should.equal("before");
    promise.should.be.fulfilled.then(function () {
        otherState.should.equal("after");
    }).should.notify(done);
});
```

Notice how `.notify(done)` is hanging directly off of `.should`, instead of appearing after a promise assertion. This
indicates to Chai as Promised that it should pass fulfillment or rejection directly through to the testing framework.
Thus, the above code will fail with a Chai as Promised error (`"expected promise to be fulfilled…"`) if `promise` is
rejected, but will fail with a simple Chai error (`expected "before" to equal "after"`) if `otherState` does not change.

Another example of where this can be useful is when performing assertions on multiple promises:

```javascript
it("should all be well", function (done) {
    Q.all([
        promiseA.should.become("happy"),
        promiseB.should.eventually.have.property("fun times"),
        promiseC.should.be.rejectedWith(TypeError, "only joyful types are allowed")
    ]).should.notify(done);
});
```

This will pass any failures of the individual promise assertions up to the test framework, instead of wrapping them in
an `"expected promise to be fulfilled…"` message as would happen if you did
`Q.all([…]).should.be.fulfilled.and.notify(done)`.

## Installation and Setup

### Node

Do an `npm install chai-as-promised` to get up and running. Then:

```javascript
var chai = require("chai");
var chaiAsPromised = require("chai-as-promised");

chai.use(chaiAsPromised);
```

You can of course put this code in a common test fixture file; for an example using [Mocha][], see
[the Chai as Promised tests themselves][fixturedemo].

### AMD

Chai as Promised supports being used as an [AMD][amd] module, registering itself anonymously (just like Chai). So,
assuming you have configured your loader to map the Chai and Chai as Promised files to the respective module IDs
`"chai"` and `"chai-as-promised"`, you can use them as follows:

```javascript
define(function (require, exports, module) {
    var chai = require("chai");
    var chaiAsPromised = require("chai-as-promised");

    chai.use(chaiAsPromised);
});
```

### `<script>` tag

If you include Chai as Promised directly with a `<script>` tag, after the one for Chai itself, then it will
automatically plug in to Chai and be ready for use:

```html
<script src="chai.js"></script>
<script src="chai-as-promised.js"></script>
```

### Karma

If you're using [Karma][], check out the accompanying [karma-chai-as-promised][] plugin.

### Browser Compatibility

Chai as Promised is only compatible with modern browsers (IE ≥9, Safari ≥6, no PhantomJS).

[presentation]: http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript
[chai]: http://chaijs.com/
[Mocha-promises]: http://mochajs.org/#asynchronous-code
[Buster-promises]: http://docs.busterjs.org/en/latest/modules/buster-test/spec/#returning-a-promise
[blue-tape]: https://github.com/spion/blue-tape
[spec]: http://promisesaplus.com/
[transformation behavior]: http://domenic.me/2012/10/14/youre-missing-the-point-of-promises/#toc_2
[Mocha]: http://mochajs.org
[fixturedemo]: https://github.com/domenic/chai-as-promised/tree/master/test/
[amd]: https://github.com/amdjs/amdjs-api/wiki/AMD
[sinon]: http://sinonjs.org/
[sinon-chai]: https://github.com/domenic/sinon-chai
[Karma]: https://karma-runner.github.io/
[karma-chai-as-promised]: https://github.com/vlkosinov/karma-chai-as-promised


text:
import sys

try:
    from setuptools import setup
except ImportError:
    from distutils.core import setup

install_requires = []
if sys.version_info < (2, 7):
    install_requires.append('argparse')

import fragments

setup(
    name='fragments',
    version='.'.join(map(str, fragments.__version__)),
    description='tool for diff-based templating / fragmentation control',
    long_description=open('README.md').read(),
    author='Matt Chisholm',
    author_email='matt-fragments@theory.org',
    url='https://github.com/glyphobet/fragments',
    packages=['fragments'],
    install_requires=install_requires,
    entry_points={
        'console_scripts': [
            'fragments = fragments.commands:_main',
        ],
    },
    data_files=[('share/fragments', ['README.md', 'bash_completion', 'LICENSE.txt'])],
    license='BSD License',
    classifiers=(
        'Development Status :: 4 - Beta',
        'Intended Audience :: Developers',
        'Natural Language :: English',
        'License :: OSI Approved :: BSD License',
        'Programming Language :: Python',
        'Programming Language :: Python :: 2.6',
        'Programming Language :: Python :: 2.7',
        'Programming Language :: Python :: 3.2',
        'Programming Language :: Python :: 3.3',
        'Programming Language :: Python :: Implementation',
        'Programming Language :: Python :: Implementation :: CPython',
        'Programming Language :: Python :: Implementation :: PyPy',
    ),
)


text:
package com.bitdubai.fermat_api.layer.osa_android.database_system;

import com.bitdubai.fermat_api.layer.all_definition.exceptions.InvalidParameterException;

/**
 *
The enum DatabaseFilterOrder
 *     defines the type order of query
 *
 *
 *  @author  Luis
 *  @version 1.0.0
 *  @since   27/03/15.
 * */
public enum DatabaseFilterOrder {

    //Modified by Manuel Perez 05/08/2015
    ASCENDING("ASC"),
    DESCENDING("DES");

    private String code;

    DatabaseFilterOrder(String code){

        this.code=code;

    }

    public String getCode(){

        return this.code;

    }

    public static DatabaseFilterOrder getByCode(String code)throws InvalidParameterException{

        switch (code){

            case "ASC":
                return DatabaseFilterOrder.ASCENDING;
            case "DES":
                return DatabaseFilterOrder.DESCENDING;
            default:
                throw new InvalidParameterException(InvalidParameterException.DEFAULT_MESSAGE, null, "Code Received: " + code, "This Code Is Not Valid for the DatabaseFilterOrder enum");

        }

    }

}


text:
package de.dotwee.rgb.canteen.view;

import android.content.Context;
import android.net.Uri;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import java.util.List;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModelProviders;
import de.dotwee.rgb.canteen.R;
import de.dotwee.rgb.canteen.model.database.models.Item;
import de.dotwee.rgb.canteen.model.database.models.Menu;

/**
 * A simple {@link Fragment} subclass.
 * Activities that contain this fragment must implement the
 * {@link DebugFragment.OnFragmentInteractionListener} interface
 * to handle interaction events.
 * Use the {@link DebugFragment#newInstance} factory method to
 * create an instance of this fragment.
 */
public class DebugFragment extends Fragment {
    // TODO: Rename parameter arguments, choose names that match
    // the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
    private static final String ARG_PARAM1 = "param1";
    private static final String ARG_PARAM2 = "param2";

    // TODO: Rename and change types of parameters
    private String mParam1;
    private String mParam2;

    private DebugViewModel debugViewModel;

    private TextView textViewMenuCount;
    private TextView textViewItemCount;

    private Button buttonClearAll;
    private Button buttonClearMenus;
    private Button buttonUpdateThisWeek;

    private OnFragmentInteractionListener mListener;

    public DebugFragment() {
        // Required empty public constructor
    }

    /**
     * Use this factory method to create a new instance of
     * this fragment using the provided parameters.
     *
     * @param param1 Parameter 1.
     * @param param2 Parameter 2.
     * @return A new instance of fragment DebugFragment.
     */
    // TODO: Rename and change types and number of parameters
    public static DebugFragment newInstance(String param1, String param2) {
        DebugFragment fragment = new DebugFragment();
        Bundle args = new Bundle();
        args.putString(ARG_PARAM1, param1);
        args.putString(ARG_PARAM2, param2);
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getArguments() != null) {
            mParam1 = getArguments().getString(ARG_PARAM1);
            mParam2 = getArguments().getString(ARG_PARAM2);
        }
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_debug, container, false);
    }

    // TODO: Rename method, update argument and hook method into UI event
    public void onButtonPressed(Uri uri) {
        if (mListener != null) {
            mListener.onFragmentInteraction(uri);
        }
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);

        textViewItemCount = view.findViewById(R.id.textViewItemCount);
        textViewMenuCount = view.findViewById(R.id.textViewMenuCount);

        buttonClearAll = view.findViewById(R.id.buttonClearAll);
        buttonClearAll.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(getContext(), "Deleting all data...", Toast.LENGTH_SHORT).show();
                debugViewModel.getMensaRepository().performDeleteAll();
            }
        });

        buttonClearMenus = view.findViewById(R.id.buttonClearMenus);
        buttonClearMenus.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(getContext(), "Deleting all menus...", Toast.LENGTH_SHORT).show();
                debugViewModel.getMensaRepository().performDeleteMenus();
            }
        });

        buttonUpdateThisWeek = view.findViewById(R.id.buttonUpdateThisWeek);
        buttonUpdateThisWeek.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(getContext(), "Updating this weeks menu...", Toast.LENGTH_SHORT).show();
                debugViewModel.getMensaRepository().performDatabaseRefresh();
            }
        });
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (context instanceof OnFragmentInteractionListener) {
            mListener = (OnFragmentInteractionListener) context;
        } else {
            throw new RuntimeException(context.toString()
                    + " must implement OnFragmentInteractionListener");
        }

        debugViewModel = ViewModelProviders.of(this).get(DebugViewModel.class);
        debugViewModel.getAllMenusLiveData().observe(this, new Observer<List<Menu>>() {
            @Override
            public void onChanged(List<Menu> menus) {
                if (textViewMenuCount != null) {
                    textViewMenuCount.setText("Menu count: " + menus.size());
                }
            }
        });

        debugViewModel.getAllItemsLiveData().observe(this, new Observer<List<Item>>() {
            @Override
            public void onChanged(List<Item> items) {
                if (textViewItemCount != null) {
                    textViewItemCount.setText("Item count: " + items.size());
                }
            }
        });

    }

    @Override
    public void onDetach() {
        super.onDetach();
        mListener = null;
    }

    /**
     * This interface must be implemented by activities that contain this
     * fragment to allow an interaction in this fragment to be communicated
     * to the activity and potentially other fragments contained in that
     * activity.
     *

     * See the Android Training lesson Communicating with Other Fragments for more information.
     */
    public interface OnFragmentInteractionListener {
        // TODO: Update argument type and name
        void onFragmentInteraction(Uri uri);
    }
}


text:
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace XenOvf.Properties {

    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.9.0.0")]
    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {

        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));

        public static Settings Default {
            get {
                return defaultInstance;
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("http://schemas.dmtf.org/ovf/envelope/1")]
        public string cimEnvelopeURI {
            get {
                return ((string)(this["cimEnvelopeURI"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("http://www.microsoft.com/technet/virtualserver/downloads/vhdspec.mspx")]
        public string winFileFormatURI {
            get {
                return ((string)(this["winFileFormatURI"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("XenServer P2V (Orela) Server")]
        public string p2vTemplate {
            get {
                return ((string)(this["p2vTemplate"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Orela")]
        public string p2vGuestName {
            get {
                return ((string)(this["p2vGuestName"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("1.0.0")]
        public string ovfversion {
            get {
                return ((string)(this["ovfversion"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("{0}")]
        public string FileURI {
            get {
                return ((string)(this["FileURI"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Virtual Hardware Requirements: {0} MB RAM; {1} CPU(s), {2} Disk(s), {3} Network(s" +
            ")")]
        public string vhsSettings {
            get {
                return ((string)(this["vhsSettings"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("CPU;MEMORY;DISK")]
        public string OvfMimimalManifest {
            get {
                return ((string)(this["OvfMimimalManifest"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("0.9;1.0;1.0.0;1.0.0a;1.0.0.b;1.0.0c;1.0.0d;1.0.1;1.0.0e")]
        public string Versions {
            get {
                return ((string)(this["Versions"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute(@"ovf=http://schemas.dmtf.org/ovf/envelope/1, xs=http://www.w3.org/2001/XMLSchema,cim=http://schemas.dmtf.org/wbem/wscim/1/common,rasd=http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData,vssd=http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData,xsi=http://www.w3.org/2001/XMLSchema-instance,xenovf=http://schemas.citrix.com/ovf/envelope/1,wsse=http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd,ds=http://www.w3.org/2000/09/xmldsig#,wsu=http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd,xenc=http://www.w3.org/2001/04/xmlenc#")]
        public string KnownNamespaces {
            get {
                return ((string)(this["KnownNamespaces"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("true")]
        public string VerifySignatureOnly {
            get {
                return ((string)(this["VerifySignatureOnly"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("pygrub")]
        public string xenPVBootloader {
            get {
                return ((string)(this["xenPVBootloader"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("graphical utf8")]
        public string xenKernelOptions {
            get {
                return ((string)(this["xenKernelOptions"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("BIOS order")]
        public string xenBootOptions {
            get {
                return ((string)(this["xenBootOptions"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("order=dc;")]
        public string xenBootParams {
            get {
                return ((string)(this["xenBootParams"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("nx=true;acpi=true;apic=true;pae=true;viridian=true;")]
        public string xenPVPlatformSetting {
            get {
                return ((string)(this["xenPVPlatformSetting"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("nx=true;acpi=true;apic=true;pae=true;stdvga=0;")]
        public string xenPlatformSetting {
            get {
                return ((string)(this["xenPlatformSetting"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("hvm-3.0-unknown")]
        public string xenDefaultVirtualSystemType {
            get {
                return ((string)(this["xenDefaultVirtualSystemType"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("xenbr0")]
        public string xenDefaultNetwork {
            get {
                return ((string)(this["xenDefaultNetwork"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("P2V Automatically created.")]
        public string xenP2VDiskName {
            get {
                return ((string)(this["xenP2VDiskName"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("vmwovf:http://www.vmware/schema/ovf")]
        public string vmwNameSpace {
            get {
                return ((string)(this["vmwNameSpace"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("network=")]
        public string xenNetworkKey {
            get {
                return ((string)(this["xenNetworkKey"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\DSP8023.xsd")]
        public string ovfEnvelopeSchemaLocation {
            get {
                return ((string)(this["ovfEnvelopeSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\DSP8027.xsd")]
        public string ovfEnvironmentSchemaLocation {
            get {
                return ((string)(this["ovfEnvironmentSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\xml.xsd")]
        public string xmlNamespaceSchemaLocation {
            get {
                return ((string)(this["xmlNamespaceSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\common.xsd")]
        public string cimCommonSchemaLocation {
            get {
                return ((string)(this["cimCommonSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\CIM_ResourceAllocationSettingData.xsd")]
        public string cimRASDSchemaLocation {
            get {
                return ((string)(this["cimRASDSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\CIM_VirtualSystemSettingData.xsd")]
        public string cimVSSDSchemaLocation {
            get {
                return ((string)(this["cimVSSDSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("http://schemas.dmtf.org/ovf/envelope/1/dsp8023.xsd")]
        public string dsp8023OnlineSchema {
            get {
                return ((string)(this["dsp8023OnlineSchema"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("false")]
        public string useOnlineSchema {
            get {
                return ((string)(this["useOnlineSchema"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("127")]
        public byte RequiredValidations {
            get {
                return ((byte)(this["RequiredValidations"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("vmwovf")]
        public string vmwNamespacePrefix {
            get {
                return ((string)(this["vmwNamespacePrefix"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("http://www.vmware.com/schema/ovf/1/envelope")]
        public string vmwEnvelopeNamespace {
            get {
                return ((string)(this["vmwEnvelopeNamespace"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute(".vhd,.pvp,.vmdk,.mf,.cert,.xva,.ovf,.wim,.vdi,.sdi,.iso,.gz")]
        public string knownFileExtensions {
            get {
                return ((string)(this["knownFileExtensions"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute(".mf")]
        public string manifestFileExtension {
            get {
                return ((string)(this["manifestFileExtension"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute(".cert")]
        public string certificateFileExtension {
            get {
                return ((string)(this["certificateFileExtension"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("SHA1")]
        public string securityAlgorithm {
            get {
                return ((string)(this["securityAlgorithm"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\secext-1.0.xsd")]
        public string wsseSchemaLocation {
            get {
                return ((string)(this["wsseSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" +
            "")]
        public string wsseOnlineSchema {
            get {
                return ((string)(this["wsseOnlineSchema"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\xenc-schema.xsd")]
        public string xencSchemaLocation {
            get {
                return ((string)(this["xencSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\wss-utility-1.0.xsd")]
        public string wsuSchemaLocation {
            get {
                return ((string)(this["wsuSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Schemas\\xmldsig-core-schema.xsd")]
        public string xmldsigSchemaLocation {
            get {
                return ((string)(this["xmldsigSchemaLocation"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RijndaelManaged")]
        public string encryptMicrosoftAlgorithmClass {
            get {
                return ((string)(this["encryptMicrosoftAlgorithmClass"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("192")]
        public string encryptKeyLength {
            get {
                return ((string)(this["encryptKeyLength"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("http://www.w3.org/2001/04/xmlenc#aes192-cbc")]
        public string encryptAlgorithmURI {
            get {
                return ((string)(this["encryptAlgorithmURI"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("CitrixEncryptedKey")]
        public string encryptKeyName {
            get {
                return ((string)(this["encryptKeyName"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.TripleDESCryptoServiceProvider")]
        public string tripledes_cbc {
            get {
                return ((string)(this["tripledes_cbc"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RijndaelManaged")]
        public string aes128_cbc {
            get {
                return ((string)(this["aes128_cbc"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RijndaelManaged")]
        public string aes256_cbc {
            get {
                return ((string)(this["aes256_cbc"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RijndaelManaged")]
        public string aes192_cbc {
            get {
                return ((string)(this["aes192_cbc"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RSACryptoServiceProvider")]
        public string rsa_1_5 {
            get {
                return ((string)(this["rsa_1_5"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RSACryptoServiceProvider")]
        public string rsa_oaep_mgf1p {
            get {
                return ((string)(this["rsa_oaep_mgf1p"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.TripleDESCryptoServiceProvider")]
        public string kw_tripledes {
            get {
                return ((string)(this["kw_tripledes"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RijndaelManaged")]
        public string kw_aes128 {
            get {
                return ((string)(this["kw_aes128"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RijndaelManaged")]
        public string kw_aes256 {
            get {
                return ((string)(this["kw_aes256"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RijndaelManaged")]
        public string kw_aes192 {
            get {
                return ((string)(this["kw_aes192"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.SHA1CryptoServiceProvider")]
        public string sha1 {
            get {
                return ((string)(this["sha1"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.SHA256CryptoServiceProvider")]
        public string sha256 {
            get {
                return ((string)(this["sha256"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.FromBase64Transform")]
        public string base64 {
            get {
                return ((string)(this["base64"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.SHA384CryptoServiceProvider")]
        public string sha384 {
            get {
                return ((string)(this["sha384"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.SHA512CryptoServiceProvider")]
        public string sha512 {
            get {
                return ((string)(this["sha512"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("xen-3.0-unknown")]
        public string xenDefaultPVVirtualSystemType {
            get {
                return ((string)(this["xenDefaultPVVirtualSystemType"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("http://www.osta.org/specs/pdf/udf260.pdf")]
        public string isoFileFormatURI {
            get {
                return ((string)(this["isoFileFormatURI"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("en-US")]
        public string Language {
            get {
                return ((string)(this["Language"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("External Tools\\xenserver-linuxfixup-disk.iso")]
        public string xenLinuxFixUpDisk {
            get {
                return ((string)(this["xenLinuxFixUpDisk"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("128")]
        public double minPasswordStrength {
            get {
                return ((double)(this["minPasswordStrength"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("sr=")]
        public string xenSRKey {
            get {
                return ((string)(this["xenSRKey"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("device=")]
        public string xenDeviceKey {
            get {
                return ((string)(this["xenDeviceKey"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.DESCryptoServiceProvider")]
        public string des {
            get {
                return ((string)(this["des"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("System.Security.Cryptography.RC2CryptoServiceProvider\r\n")]
        public string rc2 {
            get {
                return ((string)(this["rc2"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("True")]
        public bool useGZip {
            get {
                return ((bool)(this["useGZip"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("ovf:/disk/{0}")]
        public string hostresource {
            get {
                return ((string)(this["hostresource"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("CIM_OperatingSystem.xml, CIM_ResourceAllocationSettingData.xml, CIM_VirtualSystem" +
            "SettingData.xml")]
        public string mofFiles {
            get {
                return ((string)(this["mofFiles"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute(@"<?xml version=""1.0"" encoding=""utf-16""?>
<ArrayOfString xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"">
  <string>xen-3.0-unknown</string>
  <string>xen-3.0-x32</string>
  <string>xen-3.0-x86</string>
  <string>xen-3.0-x64</string>
  <string>hvm-3.0-unknown</string>
  <string>hvm-3.0-x32</string>
  <string>hvm-3.0-x86</string>
  <string>hvm-3.0-x64</string>
  <string>hvm-3.0-hvm</string>
  <string>301</string>
  <string>vmx-4</string>
  <string>vmx-04</string>
  <string>vmx-6</string>
  <string>vmx-06</string>
  <string>vmx-7</string>
  <string>vmx-07</string>
  <string>DMTF:xen:pv</string>
  <string>DMTF:xen:hvm</string>
  <string>virtualbox-2.2</string>
</ArrayOfString>")]
        public global::System.Collections.Specialized.StringCollection knownVirtualSystemTypes {
            get {
                return ((global::System.Collections.Specialized.StringCollection)(this["knownVirtualSystemTypes"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("vmx-07")]
        public string vmwHardwareType {
            get {
                return ((string)(this["vmwHardwareType"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("1.3.1")]
        public string securityVersion {
            get {
                return ((string)(this["securityVersion"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("4096")]
        public int CompressBufferSize {
            get {
                return ((int)(this["CompressBufferSize"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute(".ovf")]
        public string ovfFileExtension {
            get {
                return ((string)(this["ovfFileExtension"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("vdi=")]
        public string xenVDIKey {
            get {
                return ((string)(this["xenVDIKey"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("vmw")]
        public string VMwareNamespacePrefix {
            get {
                return ((string)(this["VMwareNamespacePrefix"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("http://www.vmware/schema/ovf")]
        public string VMwareNamespace {
            get {
                return ((string)(this["VMwareNamespace"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Audit, Error, Warning")]
        public string LogLevel {
            get {
                return ((string)(this["LogLevel"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("XenApplianceWizard.log")]
        public string LogFile {
            get {
                return ((string)(this["LogFile"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Audit, Console")]
        public string LogType {
            get {
                return ((string)(this["LogType"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("XenLocalOVF")]
        public string LogSource {
            get {
                return ((string)(this["LogSource"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("ApplicationData")]
        public string LogPath {
            get {
                return ((string)(this["LogPath"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("Plain//Stamp")]
        public string LogFormat {
            get {
                return ((string)(this["LogFormat"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("off//XenOvfLogFwd.dll,XenOvfLogFwd.Log4Net")]
        public string LogForwarding {
            get {
                return ((string)(this["LogForwarding"]));
            }
        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("[Citrix]\\[XenCenter]\\logs")]
        public string LogSubPath {
            get {
                return ((string)(this["LogSubPath"]));
            }
        }
    }
}


text:
isPositiveZero

Test if a double-precision floating-point numeric value is positive zero.

Usage

var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );

isPositiveZero( x )

Tests if a double-precision floating-point numeric value is positive zero.

var bool = isPositiveZero( 0.0 );
// returns true

bool = isPositiveZero( -0.0 );
// returns false

Examples

var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );

var bool = isPositiveZero( 0.0 );
// returns true

bool = isPositiveZero( -0.0 );
// returns false

bool = isPositiveZero( 5.0 );
// returns false

bool = isPositiveZero( -1.0 );
// returns false

bool = isPositiveZero( NaN );
// returns false

See Also

@stdlib/math/base/assert/is-negative-zero: test if a double-precision floating-point numeric value is negative zero.


text:
namespace ui {

// static
double Tween::CalculateValue(Tween::Type type, double state) {
  DCHECK_GE(state, 0);
  DCHECK_LE(state, 1);

  switch (type) {
    case EASE_IN:
      return pow(state, 2);

    case EASE_IN_2:
      return pow(state, 4);

    case EASE_IN_OUT:
      if (state < 0.5)
        return pow(state * 2, 2) / 2.0;
      return 1.0 - (pow((state - 1.0) * 2, 2) / 2.0);

    case FAST_IN_OUT:
      return (pow(state - 0.5, 3) + 0.125) / 0.25;

    case LINEAR:
      return state;

    case EASE_OUT_SNAP:
      state = 0.95 * (1.0 - pow(1.0 - state, 2));
      return state;

    case EASE_OUT:
      return 1.0 - pow(1.0 - state, 2);

    case SMOOTH_IN_OUT:
      return sin(state);

    case ZERO:
      return 0;
  }

  NOTREACHED();
  return state;
}

// static
double Tween::ValueBetween(double value, double start, double target) {
  return start + (target - start) * value;
}

// static
int Tween::ValueBetween(double value, int start, int target) {
  if (start == target)
    return start;
  double delta = static_cast<double>(target - start);
  if (delta < 0)
    delta--;
  else
    delta++;
#if defined(OS_WIN)
  return start + static_cast<int>(value * _nextafter(delta, 0));
#else
  return start + static_cast<int>(value * nextafter(delta, 0));
#endif
}

// static
gfx::Rect Tween::ValueBetween(double value,
                              const gfx::Rect& start_bounds,
                              const gfx::Rect& target_bounds) {
  return gfx::Rect(ValueBetween(value, start_bounds.x(), target_bounds.x()),
                   ValueBetween(value, start_bounds.y(), target_bounds.y()),
                   ValueBetween(value, start_bounds.width(),
                                target_bounds.width()),
                   ValueBetween(value, start_bounds.height(),
                                target_bounds.height()));
}

// static
gfx::Transform Tween::ValueBetween(double value,
                                   const gfx::Transform& start_transform,
                                   const gfx::Transform& end_transform) {
  if (value >= 1.0)
    return end_transform;
  if (value <= 0.0)
    return start_transform;

  gfx::Transform to_return = end_transform;
  to_return.Blend(start_transform, value);

  return to_return;
}

}  // namespace ui


text:
package cipher_test

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/hex"
	"fmt"
	"io"
	"os"
)

func ExampleNewGCM_encrypt() {
	// The key argument should be the AES key, either 16 or 32 bytes
	// to select AES-128 or AES-256.
	key := []byte("AES256Key-32Characters1234567890")
	plaintext := []byte("exampleplaintext")

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err.Error())
	}

	// Never use more than 2^32 random nonces with a given key because of the risk of a repeat.
	nonce := make([]byte, 12)
	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
		panic(err.Error())
	}

	aesgcm, err := cipher.NewGCM(block)
	if err != nil {
		panic(err.Error())
	}

	ciphertext := aesgcm.Seal(nil, nonce, plaintext, nil)
	fmt.Printf("%x\n", ciphertext)
}

func ExampleNewGCM_decrypt() {
	// The key argument should be the AES key, either 16 or 32 bytes
	// to select AES-128 or AES-256.
	key := []byte("AES256Key-32Characters1234567890")
	ciphertext, _ := hex.DecodeString("1019aa66cd7c024f9efd0038899dae1973ee69427f5a6579eba292ffe1b5a260")

	nonce, _ := hex.DecodeString("37b8e8a308c354048d245f6d")

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err.Error())
	}

	aesgcm, err := cipher.NewGCM(block)
	if err != nil {
		panic(err.Error())
	}

	plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil)
	if err != nil {
		panic(err.Error())
	}

	fmt.Printf("%s\n", plaintext)
	// Output: exampleplaintext
}

func ExampleNewCBCDecrypter() {
	key := []byte("example key 1234")
	ciphertext, _ := hex.DecodeString("f363f3ccdcb12bb883abf484ba77d9cd7d32b5baecb3d4b1b3e0e4beffdb3ded")

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// The IV needs to be unique, but not secure. Therefore it's common to
	// include it at the beginning of the ciphertext.
	if len(ciphertext) < aes.BlockSize {
		panic("ciphertext too short")
	}
	iv := ciphertext[:aes.BlockSize]
	ciphertext = ciphertext[aes.BlockSize:]

	// CBC mode always works in whole blocks.
	if len(ciphertext)%aes.BlockSize != 0 {
		panic("ciphertext is not a multiple of the block size")
	}

	mode := cipher.NewCBCDecrypter(block, iv)

	// CryptBlocks can work in-place if the two arguments are the same.
	mode.CryptBlocks(ciphertext, ciphertext)

	// If the original plaintext lengths are not a multiple of the block
	// size, padding would have to be added when encrypting, which would be
	// removed at this point. For an example, see
	// https://tools.ietf.org/html/rfc5246#section-6.2.3.2. However, it's
	// critical to note that ciphertexts must be authenticated (i.e. by
	// using crypto/hmac) before being decrypted in order to avoid creating
	// a padding oracle.

	fmt.Printf("%s\n", ciphertext)
	// Output: exampleplaintext
}

func ExampleNewCBCEncrypter() {
	key := []byte("example key 1234")
	plaintext := []byte("exampleplaintext")

	// CBC mode works on blocks so plaintexts may need to be padded to the
	// next whole block. For an example of such padding, see
	// https://tools.ietf.org/html/rfc5246#section-6.2.3.2. Here we'll
	// assume that the plaintext is already of the correct length.
	if len(plaintext)%aes.BlockSize != 0 {
		panic("plaintext is not a multiple of the block size")
	}

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// The IV needs to be unique, but not secure. Therefore it's common to
	// include it at the beginning of the ciphertext.
	ciphertext := make([]byte, aes.BlockSize+len(plaintext))
	iv := ciphertext[:aes.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		panic(err)
	}

	mode := cipher.NewCBCEncrypter(block, iv)
	mode.CryptBlocks(ciphertext[aes.BlockSize:], plaintext)

	// It's important to remember that ciphertexts must be authenticated
	// (i.e. by using crypto/hmac) as well as being encrypted in order to
	// be secure.

	fmt.Printf("%x\n", ciphertext)
}

func ExampleNewCFBDecrypter() {
	key := []byte("example key 1234")
	ciphertext, _ := hex.DecodeString("22277966616d9bc47177bd02603d08c9a67d5380d0fe8cf3b44438dff7b9")

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// The IV needs to be unique, but not secure. Therefore it's common to
	// include it at the beginning of the ciphertext.
	if len(ciphertext) < aes.BlockSize {
		panic("ciphertext too short")
	}
	iv := ciphertext[:aes.BlockSize]
	ciphertext = ciphertext[aes.BlockSize:]

	stream := cipher.NewCFBDecrypter(block, iv)

	// XORKeyStream can work in-place if the two arguments are the same.
	stream.XORKeyStream(ciphertext, ciphertext)
	fmt.Printf("%s", ciphertext)
	// Output: some plaintext
}

func ExampleNewCFBEncrypter() {
	key := []byte("example key 1234")
	plaintext := []byte("some plaintext")

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// The IV needs to be unique, but not secure. Therefore it's common to
	// include it at the beginning of the ciphertext.
	ciphertext := make([]byte, aes.BlockSize+len(plaintext))
	iv := ciphertext[:aes.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		panic(err)
	}

	stream := cipher.NewCFBEncrypter(block, iv)
	stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)

	// It's important to remember that ciphertexts must be authenticated
	// (i.e. by using crypto/hmac) as well as being encrypted in order to
	// be secure.
}

func ExampleNewCTR() {
	key := []byte("example key 1234")
	plaintext := []byte("some plaintext")

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// The IV needs to be unique, but not secure. Therefore it's common to
	// include it at the beginning of the ciphertext.
	ciphertext := make([]byte, aes.BlockSize+len(plaintext))
	iv := ciphertext[:aes.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		panic(err)
	}

	stream := cipher.NewCTR(block, iv)
	stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)

	// It's important to remember that ciphertexts must be authenticated
	// (i.e. by using crypto/hmac) as well as being encrypted in order to
	// be secure.

	// CTR mode is the same for both encryption and decryption, so we can
	// also decrypt that ciphertext with NewCTR.

	plaintext2 := make([]byte, len(plaintext))
	stream = cipher.NewCTR(block, iv)
	stream.XORKeyStream(plaintext2, ciphertext[aes.BlockSize:])

	fmt.Printf("%s\n", plaintext2)
	// Output: some plaintext
}

func ExampleNewOFB() {
	key := []byte("example key 1234")
	plaintext := []byte("some plaintext")

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// The IV needs to be unique, but not secure. Therefore it's common to
	// include it at the beginning of the ciphertext.
	ciphertext := make([]byte, aes.BlockSize+len(plaintext))
	iv := ciphertext[:aes.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		panic(err)
	}

	stream := cipher.NewOFB(block, iv)
	stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)

	// It's important to remember that ciphertexts must be authenticated
	// (i.e. by using crypto/hmac) as well as being encrypted in order to
	// be secure.

	// OFB mode is the same for both encryption and decryption, so we can
	// also decrypt that ciphertext with NewOFB.

	plaintext2 := make([]byte, len(plaintext))
	stream = cipher.NewOFB(block, iv)
	stream.XORKeyStream(plaintext2, ciphertext[aes.BlockSize:])

	fmt.Printf("%s\n", plaintext2)
	// Output: some plaintext
}

func ExampleStreamReader() {
	key := []byte("example key 1234")

	inFile, err := os.Open("encrypted-file")
	if err != nil {
		panic(err)
	}
	defer inFile.Close()

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// If the key is unique for each ciphertext, then it's ok to use a zero
	// IV.
	var iv [aes.BlockSize]byte
	stream := cipher.NewOFB(block, iv[:])

	outFile, err := os.OpenFile("decrypted-file", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		panic(err)
	}
	defer outFile.Close()

	reader := &cipher.StreamReader{S: stream, R: inFile}
	// Copy the input file to the output file, decrypting as we go.
	if _, err := io.Copy(outFile, reader); err != nil {
		panic(err)
	}

	// Note that this example is simplistic in that it omits any
	// authentication of the encrypted data. If you were actually to use
	// StreamReader in this manner, an attacker could flip arbitrary bits in
	// the output.
}

func ExampleStreamWriter() {
	key := []byte("example key 1234")

	inFile, err := os.Open("plaintext-file")
	if err != nil {
		panic(err)
	}
	defer inFile.Close()

	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}

	// If the key is unique for each ciphertext, then it's ok to use a zero
	// IV.
	var iv [aes.BlockSize]byte
	stream := cipher.NewOFB(block, iv[:])

	outFile, err := os.OpenFile("encrypted-file", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		panic(err)
	}
	defer outFile.Close()

	writer := &cipher.StreamWriter{S: stream, W: outFile}
	// Copy the input file to the output file, encrypting as we go.
	if _, err := io.Copy(writer, inFile); err != nil {
		panic(err)
	}

	// Note that this example is simplistic in that it omits any
	// authentication of the encrypted data. If you were actually to use
	// StreamReader in this manner, an attacker could flip arbitrary bits in
	// the decrypted result.
}


text:
/* jslint node: true, sub: true */
'use strict';

var utilex = require('utilex'),
    cache  = require('../lib/cache');

var appArgs   = utilex.appArgs(),
    appConfig = {isHeapdump: false},
    appCache  = cache({debug: false, globLimit: 134217728, eviction: false});

// config
if(typeof appArgs['heapdump'] !== 'undefined') {
  var heapdump = require('heapdump');
  appConfig.isHeapdump = true;
}

// Tests

// Init vars
var entries      = [],
    entryLimit   = 100000,
    checklist    = [],
    checklistLen = 0,
    randKey,
    randVal,
    hrtime,
    hrtimeGlob,
    hrtimeDiff = function(hrtime) {
      hrtime = process.hrtime(hrtime);
      return ((hrtime[0]*1000)+(hrtime[1]*1.0e-6)).toFixed(4);
    },
    i;

hrtimeGlob = process.hrtime();
utilex.conLog('Benchmark process is starting...');

// Create entries
utilex.conLog('Preparing ' + entryLimit + ' entries...');
hrtime = process.hrtime();
for(i = 0; i < entryLimit; i++) {
  randKey = (Math.random() + 1).toString(36).substring(2) + (Math.random() + 1).toString(36).substring(2);
  randVal = (Math.random() + 1).toString(36).substring(2) + (Math.random() + 1).toString(36).substring(2) + (Math.random() + 1).toString(36).substring(2);

  if(Math.random() > 0.5) checklist.push(randKey);

  entries.push([randKey, randVal]);
}
utilex.conLog('Done! ' + hrtimeDiff(hrtime) + 'ms');
checklistLen = checklist.length;

// Add entries
utilex.conLog('Caching ' + entryLimit + ' entries...');
hrtime = process.hrtime();
for(i = 0; i < entryLimit; i++) {
  appCache.set(entries[i][0], entries[i][1]);
}
utilex.conLog('Done! ' + hrtimeDiff(hrtime) + 'ms');

// Get entries
utilex.conLog('Checking ' + checklistLen + ' randomly selected entries...');
hrtime = process.hrtime();
for(i = 0; i < checklistLen; i++) {
  appCache.get(checklist[i]);
}
utilex.conLog('Done! ' + hrtimeDiff(hrtime) + 'ms');

// Delete entries
utilex.conLog('Deleting ' + checklistLen + ' randomly selected entries...');
hrtime = process.hrtime();
for(i = 0; i < checklistLen; i++) {
  appCache.del(checklist[i]);
}
utilex.conLog('Done! ' + hrtimeDiff(hrtime) + 'ms');

// Stats
utilex.conLog('Stats for entries:' + JSON.stringify(appCache.stats().entries));
console.log(appCache.stats().entries);

utilex.conLog('Benchmark process is done! ' + hrtimeDiff(hrtimeGlob) + 'ms');

// heapdump
if(appConfig.isHeapdump === true) {
  heapdump.writeSnapshot(__dirname + '/dump-' + Date.now() + '.heapsnapshot');
}

process.exit(0);


text:
#import <IDEInterfaceBuilderKit/IBDocumentArchivingSchemaBitmask.h>

@interface IBDocumentArchivingSchemaBitmaskNSEventMask : IBDocumentArchivingSchemaBitmask
{
}

+ (id)sharedInstance;

@end


text:
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.8-b130911.1802
// See http://java.sun.com/xml/jaxb
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2016.10.09 at 10:10:23 AM CST
//

package elong;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import java.util.List;
import com.alibaba.fastjson.annotation.JSONField;
import javax.xml.bind.annotation.XmlType;

/**
 *
Java class for Recipient complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType name="Recipient">
 *   <complexContent>
 *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       <sequence>
 *         <element name="Province" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="City" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="District" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="Street" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="PostalCode" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="Name" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="Phone" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *         <element name="Email" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/>
 *       </sequence>
 *     </restriction>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Recipient", propOrder = {
    "province",
    "city",
    "district",
    "street",
    "postalCode",
    "name",
    "phone",
    "email"
})
public class Recipient {

    @JSONField(name = "Province")
    protected String province;
    @JSONField(name = "City")
    protected String city;
    @JSONField(name = "District")
    protected String district;
    @JSONField(name = "Street")
    protected String street;
    @JSONField(name = "PostalCode")
    protected String postalCode;
    @JSONField(name = "Name")
    protected String name;
    @JSONField(name = "Phone")
    protected String phone;
    @JSONField(name = "Email")
    protected String email;

    /**
     * Gets the value of the province property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getProvince() {
        return province;
    }

    /**
     * Sets the value of the province property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setProvince(String value) {
        this.province = value;
    }

    /**
     * Gets the value of the city property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getCity() {
        return city;
    }

    /**
     * Sets the value of the city property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setCity(String value) {
        this.city = value;
    }

    /**
     * Gets the value of the district property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getDistrict() {
        return district;
    }

    /**
     * Sets the value of the district property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setDistrict(String value) {
        this.district = value;
    }

    /**
     * Gets the value of the street property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getStreet() {
        return street;
    }

    /**
     * Sets the value of the street property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setStreet(String value) {
        this.street = value;
    }

    /**
     * Gets the value of the postalCode property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getPostalCode() {
        return postalCode;
    }

    /**
     * Sets the value of the postalCode property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setPostalCode(String value) {
        this.postalCode = value;
    }

    /**
     * Gets the value of the name property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getName() {
        return name;
    }

    /**
     * Sets the value of the name property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setName(String value) {
        this.name = value;
    }

    /**
     * Gets the value of the phone property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getPhone() {
        return phone;
    }

    /**
     * Sets the value of the phone property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setPhone(String value) {
        this.phone = value;
    }

    /**
     * Gets the value of the email property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getEmail() {
        return email;
    }

    /**
     * Sets the value of the email property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setEmail(String value) {
        this.email = value;
    }

}


text:
package cbreaker

import (
	"net/http"
	"time"

	"github.com/vulcand/oxy/v2/utils"
)

// Option represents an option you can pass to New.
type Option func(*CircuitBreaker) error

// Logger defines the logger used by CircuitBreaker.
func Logger(l utils.Logger) Option {
	return func(c *CircuitBreaker) error {
		c.log = l
		return nil
	}
}

// Verbose additional debug information.
func Verbose(verbose bool) Option {
	return func(c *CircuitBreaker) error {
		c.verbose = verbose
		return nil
	}
}

// FallbackDuration is how long the CircuitBreaker will remain in the Tripped
// state before trying to recover.
func FallbackDuration(d time.Duration) Option {
	return func(c *CircuitBreaker) error {
		c.fallbackDuration = d
		return nil
	}
}

// RecoveryDuration is how long the CircuitBreaker will take to ramp up
// requests during the Recovering state.
func RecoveryDuration(d time.Duration) Option {
	return func(c *CircuitBreaker) error {
		c.recoveryDuration = d
		return nil
	}
}

// CheckPeriod is how long the CircuitBreaker will wait between successive
// checks of the breaker condition.
func CheckPeriod(d time.Duration) Option {
	return func(c *CircuitBreaker) error {
		c.checkPeriod = d
		return nil
	}
}

// OnTripped sets a SideEffect to run when entering the Tripped state.
// Only one SideEffect can be set for this hook.
func OnTripped(s SideEffect) Option {
	return func(c *CircuitBreaker) error {
		c.onTripped = s
		return nil
	}
}

// OnStandby sets a SideEffect to run when entering the Standby state.
// Only one SideEffect can be set for this hook.
func OnStandby(s SideEffect) Option {
	return func(c *CircuitBreaker) error {
		c.onStandby = s
		return nil
	}
}

// Fallback defines the http.Handler that the CircuitBreaker should route
// requests to when it prevents a request from taking its normal path.
func Fallback(h http.Handler) Option {
	return func(c *CircuitBreaker) error {
		c.fallback = h
		return nil
	}
}

// ResponseFallbackOption represents an option you can pass to NewResponseFallback.
type ResponseFallbackOption func(*ResponseFallback) error

// ResponseFallbackLogger defines the logger used by ResponseFallback.
func ResponseFallbackLogger(l utils.Logger) ResponseFallbackOption {
	return func(c *ResponseFallback) error {
		c.log = l
		return nil
	}
}

// ResponseFallbackDebug additional debug information.
func ResponseFallbackDebug(debug bool) ResponseFallbackOption {
	return func(c *ResponseFallback) error {
		c.debug = debug
		return nil
	}
}

// RedirectFallbackOption represents an option you can pass to NewRedirectFallback.
type RedirectFallbackOption func(*RedirectFallback) error

// RedirectFallbackLogger defines the logger used by ResponseFallback.
func RedirectFallbackLogger(l utils.Logger) RedirectFallbackOption {
	return func(c *RedirectFallback) error {
		c.log = l
		return nil
	}
}

// RedirectFallbackDebug additional debug information.
func RedirectFallbackDebug(debug bool) RedirectFallbackOption {
	return func(c *RedirectFallback) error {
		c.debug = debug
		return nil
	}
}


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="sickworm.com.misportsconnectwidget.MainActivity">

    <sickworm.com.misportsconnectview.MISportsConnectView
        android:id="@+id/mi_sports_loading_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

    <Button
        android:id="@+id/connect_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_alignParentBottom="true"
        android:layout_marginBottom="32dp"
        android:text="@string/connect"/>
</RelativeLayout>


text:
/*****************************************************************************/
/*  SNPRINTF.C v15.12.3                                                      */
/*                                                                           */
/* Copyright (c) 2001-2016 Texas Instruments Incorporated                    */
/* http://www.ti.com/                                                        */
/*                                                                           */
/*  Redistribution and  use in source  and binary forms, with  or without    */
/*  modification,  are permitted provided  that the  following conditions    */
/*  are met:                                                                 */
/*                                                                           */
/*     Redistributions  of source  code must  retain the  above copyright    */
/*     notice, this list of conditions and the following disclaimer.         */
/*                                                                           */
/*     Redistributions in binary form  must reproduce the above copyright    */
/*     notice, this  list of conditions  and the following  disclaimer in    */
/*     the  documentation  and/or   other  materials  provided  with  the    */
/*     distribution.                                                         */
/*                                                                           */
/*     Neither the  name of Texas Instruments Incorporated  nor the names    */
/*     of its  contributors may  be used to  endorse or  promote products    */
/*     derived  from   this  software  without   specific  prior  written    */
/*     permission.                                                           */
/*                                                                           */
/*  THIS SOFTWARE  IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS    */
/*  "AS IS"  AND ANY  EXPRESS OR IMPLIED  WARRANTIES, INCLUDING,  BUT NOT    */
/*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR    */
/*  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT    */
/*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,    */
/*  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL  DAMAGES  (INCLUDING, BUT  NOT    */
/*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,    */
/*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY    */
/*  THEORY OF  LIABILITY, WHETHER IN CONTRACT, STRICT  LIABILITY, OR TORT    */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE    */
/*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     */
/*                                                                           */
/*****************************************************************************/

/*****************************************************************************/
/* Functions:                                                                */
/*    SNPRINTF -  Copy formatted output to a string                          */
/*    _OUTC    -  Put a character in a string                                */
/*    _OUTS    -  Append a string to another string                          */
/*****************************************************************************/
#include <stdio.h>
#include <format.h>
#include <stdarg.h>
#include <string.h>

extern _CODE_ACCESS int __TI_printfi(char **_format, va_list _ap, void *_op,
                                     int (*_outc)(char, void *),
                                     int (*_outs)(char *, void *, int));

static int _outc(char c, void *_op);
static int _outs(char *s, void *_op, int len);

struct holder {
    char  *out_end;
    size_t n;
    size_t written;
};

/*****************************************************************************/
/* SNPRINTF  -  Copy formatted output to a string                            */
/*                                                                           */
/*    This function passes a format string and an argument list to           */
/*    __TI_printfi, and writes the result string to the string _STRING.      */
/*                                                                           */
/*****************************************************************************/
_CODE_ACCESS int snprintf(char *_string, size_t _n, const char *_format, ...)
{
    va_list _ap;
    int    rval;
    char  *fptr = (char *)_format;
    struct holder holder;

    if (_n == 0)  /* write nothing */
       holder.n = 0;
    else          /* set up buffer */
       holder.n = _n - 1;

    holder.written = 0;
    holder.out_end = _string;

    va_start(_ap, _format);
    rval = __TI_printfi(&fptr, _ap, (void *)&holder, _outc, _outs);
    va_end(_ap);

    if (_n) *holder.out_end = '\0';

    return rval;
}

/*****************************************************************************/
/* _OUTC -  Put a character in a string                                      */
/*****************************************************************************/
static int _outc(char c, void *_op)
{
    struct holder *holder = (struct holder *)_op;

    if (holder->written < holder->n)
	*holder->out_end++ = c;

    holder->written++;

    return c;
}

/*****************************************************************************/
/* _OUTS -  Append a string to another string                                */
/*****************************************************************************/
static int _outs(char *s, void *_op, int len)
{
    struct holder *holder = (struct holder *)_op;

    if (holder->written < holder->n)
    {
	size_t space = holder->n - holder->written;
	size_t use = len > space ? space : len;
	memcpy(holder->out_end, s, use);
	holder->out_end += use;
    }

    holder->written += len;

    return len;
}


text:
function newsd = OpenSimpleDaq(sd)

% OPENSIMPLEDAQ - Opens a SimpleDaq device
%
%     NEWSD = OPENSIMPLEDAQ(SD)
%
%  Calls the open function for the SimpleDaq device SD.
%
%    Literally returns NEWSD = SD.daqname_OpenSimpleDaq(SD)
%

eval(['newsd = ' sd.daqname '_OpenSimpleDaq(sd);']);


text:
package org.apache.mesos.chronos.scheduler.jobs

import java.util.concurrent.Callable

import org.joda.time.DateTime

/**
  * A wrapper around a task-tuple (taskId, baseJob), which appends the tuple to the job queue once the task is due.
  *
  * @author Florian Leibert (flo@leibert.de)
  */
class ScheduledTask(
                     val taskId: String,
                     val due: DateTime,
                     val job: BaseJob,
                     val taskManager: TaskManager)
  extends Callable[Void] {

  def call(): Void = {
    //TODO(FL): Think about pulling the state updating into the TaskManager.
    taskManager.log.info("Triggering: '%s'".format(job.name))
    taskManager.removeTaskFutureMapping(this)
    taskManager.enqueue(taskId, job.highPriority)
    null
  }
}


text:
<?php
namespace Core\LocaleBundle\Controller;

use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Response;

/**
 * @Route("/locale")
 */
class LocaleController extends Controller
{
    /**
     * Dropdown de idioma apresentado no layout principal
     * @Template()
     */
    public function layoutDropdownAction ()
    {
        /** @var $systemLanguageBusiness \Core\SystemLanguageBundle\Business\SystemLanguageBusiness */
        $systemLanguageBusiness = $this->get("CoreSystemLanguages.SystemLanguageBusiness");
        $languages = $systemLanguageBusiness->returnAllLanguages();
        return array(
            "currentLanguage" => $this->get("session")->getLocale(),
            "languages" => $languages,
        );
    }

    /**
     * Altera o idioma do sistema
     * @Route("/set/{lang}", name="CoreLocale_Locale_set", options={"expose"=true})
     */
    public function setAction ($lang)
    {
        $this->getRequest()->getSession()->set('_locale', $lang);
        if ($this->getRequest()->query->get('returnTo')) {
            $destination = $this->getRequest()->query->get('returnTo');
        } else if (isset($_SERVER['HTTP_REFERER'])) {
            $destination = $_SERVER['HTTP_REFERER'];
        } else {
            $destination = $this->generateUrl("CoreIndex_index");
        }
        return $this->redirect($destination);
    }
}


text:
import argparse
import logging
import os
import sys
import re
import csv
from collections import OrderedDict

def initialize_logger():
  logger = logging.getLogger('enclone_to_clonotype')
  loglevel = logging.INFO
  logger.setLevel(loglevel)

  formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)-8s - %(message)s')

  # create console handler and set level to info
  handler = logging.StreamHandler()
  handler.setLevel(loglevel)
  handler.setFormatter(formatter)
  logger.addHandler(handler)

  return(logger)

def getValidFilename(s):
  s = str(s).strip().replace(' ', '_')
  return re.sub(r'(?u)[^-\w.]', '', s)

def runCommand(command, logger):
  logger.info("run : " + command )
  os.system(command)

def check_file(filename, parser):
  if not os. path. isfile(filename):
    print("error: file not exists: " + filename)
    parser.print_help()
    sys.exit(1)

def read_file_map(fileName):
  result = OrderedDict()
  with open(fileName) as fh:
    for line in fh:
      filepath, name = line.strip().split('\t', 1)
      result[name] = filepath.strip()
  return(result)

def sortByCells(val):
    return val['n']

def getValue(rows, colname):
  result = ""
  for row in rows:
    if row[colname] != "":
      result = row[colname]
      break
  return(result)

def getCdr3AA(rows, colname, cdr3map):
  result = getValue(rows, colname)
  chain = ""
  if result != "":
    chain = cdr3map[result]
    result = chain + ":" + result
  return(result, chain)

def getCdr3DNA(rows, colname, chain):
  result = getValue(rows, colname)
  if result != "":
    result = chain + ":" + result
  return(result)

def getChain(idx, rows, cdr3map):
  index = str(idx)
  aa, chain = getCdr3AA(rows, 'cdr3_aa' + index, cdr3map)
  dna = getCdr3DNA(rows, 'cdr3_dna' + index, chain)
  v_name = getValue(rows, 'v_name' + index)
  d_name = getValue(rows, 'd_name' + index)
  j_name = getValue(rows, 'j_name' + index)
  return {"aa":aa, "dna":dna, "v_name":v_name, "d_name":d_name, "j_name":j_name}

def mergeChain(clono_data, value_map):
  if value_map['aa'] != "":
    clono_data['aa'].append(value_map['aa'])
    clono_data['dna'].append(value_map['dna'])
    clono_data['v_name'].append(value_map['v_name'])
    clono_data['d_name'].append(value_map['d_name'])
    clono_data['j_name'].append(value_map['j_name'])
  return(clono_data)

def add_clono_data(cid, frequency, proportion, rows, cdr3map, samples, clono_types):
  clono_data = {"clonotype_id":cid, "frequency":frequency, "proportion":proportion, "aa":[], "dna":[], "v_name":[], "d_name":[],"j_name":[]}
  for chain in range(1,5):
    chain_map = getChain(chain, rows, cdr3map)
    clono_data = mergeChain(clono_data, chain_map)

  sample_map = {}
  all_barcodes = []
  for row in rows:
    barcodes = row['barcodes'].split(',')
    all_barcodes += barcodes
    if '_' in barcodes[0]:
      for barcode in barcodes:
        m = re.search('(.+)_', barcode)
        sample = m.group(1)
        samples.append(sample)
        if sample in sample_map:
          sample_map[sample] += 1
        else:
          sample_map[sample] = 1
  clono_data['cells'] = sample_map
  clono_data['barcodes'] = sorted(all_barcodes)
  clono_types.append(clono_data)

def write_to_file(output_file, clono_types, samples):
  with open(output_file, "wt") as fout:
    fout.write("clonotype_id,frequency,proportion,cdr3s_aa,cdr3s_nt,%s,v_names,d_names,j_names,cells\n" % ",".join(samples))
    for clono_data in clono_types:
      sample_map = clono_data['cells']
      cell_counts = []
      for sample in samples:
        cell_counts.append(str(sample_map[sample]) if sample in sample_map else "0")

      #clono_data = {"clonotype_id":cid, "frequency":frequency, "proportion":proportion, "aa":[], "dna":[], "v_name":[], "d_name":[],"j_name":[]}

      fout.write("%s,%d,%f,%s,%s,%s,%s,%s,%s,%s\n" % (
        clono_data['clonotype_id'],
        clono_data['frequency'],
        clono_data['proportion'],
        ";".join(clono_data['aa']),
        ";".join(clono_data['dna']),
        ",".join(cell_counts),
        ";".join(clono_data['v_name']),
        ";".join(clono_data['d_name']),
        ";".join(clono_data['j_name']),
        ";".join(clono_data['barcodes'])
        ))

def convert(enclone_file, chain_file, output_file, logger):
  cdr3map = {}
  with open(chain_file) as fin:
    fin.readline()
    for line in fin:
      cdr3, chain = line.strip().split('\t', 1)
      cdr3map[cdr3] = chain

  rows = []
  with open(enclone_file, "rt") as fin:
    reader = csv.DictReader(fin)
    for row in reader:
      rows.append(row)

  group_clono_map = {}
  total_cells = 0
  for row in rows:
    row['n'] = int(row['n'])
    total_cells += row['n']
    group_id = int(row['group_id'])
    clono_map = group_clono_map.setdefault(group_id, {})
    clonotype_id = int(row['clonotype_id'])
    clono_map.setdefault(clonotype_id, []).append(row)

  #rows.sort(key=sortByCells, reverse=True)

  clono_types = []
  subclono_types = []
  samples = []
  for group_id in sorted(group_clono_map.keys()):
    clono_map = group_clono_map[group_id]
    for clonotype_id in sorted(clono_map.keys()):
      cid = f"g{str(group_id).zfill(5)}c{str(clonotype_id).zfill(2)}"
      rows = clono_map[clonotype_id]
      frequency = int(rows[0]['clonotype_ncells'])
      proportion = frequency / total_cells

      add_clono_data(cid, frequency, proportion, rows, cdr3map, samples, clono_types)
      for row in rows:
        r_cid = cid + "s" + row['exact_subclonotype_id']
        r_frequency = int(row['n'])
        r_proportion = r_frequency / total_cells

        add_clono_data(r_cid, r_frequency, r_proportion, [row], cdr3map, samples, subclono_types)

  samples = sorted([s for s in set(samples)])
  print(samples)

  assert total_cells == sum(clono_data['frequency'] for clono_data in clono_types)
  assert total_cells == sum(clono_data['frequency'] for clono_data in subclono_types)

  write_to_file(output_file, clono_types, samples)

  split_tup = os.path.splitext(output_file)
  sub_output_file = split_tup[0] + ".sub" + split_tup[1]
  write_to_file(sub_output_file, subclono_types, samples)

  logger.info("done")

def main():
  parser = argparse.ArgumentParser(description="enclone to clonotypes",
                                   formatter_class=argparse.ArgumentDefaultsHelpFormatter)

  DEBUG = False
  NOT_DEBUG = not DEBUG

  parser.add_argument('-i', '--input', action='store', nargs='?', help="Input enclone file", required=NOT_DEBUG)
  parser.add_argument('-c', '--chain', action='store', nargs='?', help="Input cdr3 chain file", required=NOT_DEBUG)
  parser.add_argument('-o', '--output', action='store', nargs='?', help="Output clonotype file", required=NOT_DEBUG)

  if not DEBUG and len(sys.argv)==1:
    parser.print_help()
    sys.exit(1)

  args = parser.parse_args()

  if DEBUG:
    args.input="/data/h_gelbard_lab/projects/20220508_scRNA_3669/clonotype_02_enclone/result/AG3669.pchain4.csv"
    args.chain="/data/h_gelbard_lab/projects/20220508_scRNA_3669/clonotype_01_merge/result/all_contig_annotations.json.cdr3"
    args.output="/data/h_gelbard_lab/projects/20220508_scRNA_3669/clonotype_03_convert/result/AG3669.clonotype.csv"

  check_file(args.input, parser)
  check_file(args.chain, parser)

  logger = initialize_logger()
  convert(args.input, args.chain, args.output, logger)

if __name__ == "__main__":
    main()


text:
"""
Eventloop for integration with Python3 asyncio.

Note that we can't use "yield from", because the package should be installable
under Python 2.6 as well, and it should contain syntactically valid Python 2.6
code.
"""
from __future__ import unicode_literals

__all__ = (
    'AsyncioTimeout',
)

class AsyncioTimeout(object):
    """
    Call the `timeout` function when the timeout expires.
    Every call of the `reset` method, resets the timeout and starts a new
    timer.
    """
    def __init__(self, timeout, callback, loop):
        self.timeout = timeout
        self.callback = callback
        self.loop = loop

        self.counter = 0
        self.running = True

    def reset(self):
        """
        Reset the timeout. Starts a new timer.
        """
        self.counter += 1
        local_counter = self.counter

        def timer_timeout():
            if self.counter == local_counter and self.running:
                self.callback()

        self.loop.call_later(self.timeout, timer_timeout)

    def stop(self):
        """
        Ignore timeout. Don't call the callback anymore.
        """
        self.running = False