text:
package com.intellij.execution.ui.actions;

import com.intellij.execution.ui.layout.Grid;
import com.intellij.execution.ui.layout.Tab;
import com.intellij.execution.ui.layout.ViewContext;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.project.DumbAwareAction;
import com.intellij.ui.content.Content;
import org.jetbrains.annotations.Nullable;

public abstract class BaseViewAction extends DumbAwareAction {

  @Override
  public final void update(final AnActionEvent e) {
    ViewContext context = getViewFacade(e);
    Content[] content = getContent(e);

    if (context != null && content != null) {
      if (containsInvalidContent(content)) {
        e.getPresentation().setEnabled(false);
      } else {
        update(e, context, content);
      }
    } else {
      e.getPresentation().setEnabled(false);
    }
  }

  private boolean containsInvalidContent(Content[] content) {
    for (Content each : content) {
      if (!each.isValid()) {
        return true;
      }
    }

    return false;
  }

  protected void update(AnActionEvent e, ViewContext context, Content[] content) {

  }

  @Override
  public final void actionPerformed(final AnActionEvent e) {
    actionPerformed(e, getViewFacade(e), getContent(e));
  }

  protected abstract void actionPerformed(AnActionEvent e, ViewContext context, Content[] content);

  @Nullable
  private ViewContext getViewFacade(final AnActionEvent e) {
    return e.getData(ViewContext.CONTEXT_KEY);
  }

  @Nullable
  private Content[] getContent(final AnActionEvent e) {
    return e.getData(ViewContext.CONTENT_KEY);
  }

  @Nullable
  protected static Tab getTabFor(final ViewContext context, final Content[] content) {
    Grid grid = context.findGridFor(content[0]);
    return context.getTabFor(grid);
  }

  protected final void setEnabled(AnActionEvent e, boolean enabled) {
    e.getPresentation().setVisible(enabled);
  }
}


text:
package edu.usu.sdl.openstorefront.doc;

import edu.usu.sdl.openstorefront.doc.model.APIResourceModel;
import edu.usu.sdl.openstorefront.web.rest.RestConfiguration;
import edu.usu.sdl.openstorefront.web.rest.resource.BaseResource;
import java.util.ArrayList;
import java.util.List;
import net.sourceforge.stripes.util.ResolverUtil;
import org.junit.Test;

/**
 * API Doc Generation test
 *
 * @author dshurtleff
 */
public class JaxrsProcessorTest
{

	/**
	 * Test of processRestClass method, of class JaxrsProcessor.
	 */
	@Test
	public void testProcessRestClass()
	{
		System.out.println("Checking main Resources");
		ResolverUtil resolverUtil = new ResolverUtil();
		resolverUtil.find(new ResolverUtil.IsA(BaseResource.class), "edu.usu.sdl.openstorefront.web.rest");

		List<Class> classList = new ArrayList<>();
		classList.addAll(resolverUtil.getClasses());
		for (Class resourceClass : classList) {
			System.out.println("Resources: " + resourceClass.getName());
			APIResourceModel result = JaxrsProcessor.processRestClass(resourceClass, RestConfiguration.APPLICATION_BASE_PATH);
		}
		System.out.println("Done");
	}

}

redpajama_set_name: RedPajamaGithub


text:
package org.consumersunion.stories.dashboard.client.application.widget.addto;

import org.consumersunion.stories.common.shared.model.StorySelectField;

import com.gwtplatform.mvp.client.UiHandlers;

public interface AddToUiHandlers extends UiHandlers {
    void onGoClicked();

    void onStorySelectFieldChanged(StorySelectField currentSelectField);

    void reset();

    int getNumberOfSelectedStories();
}


text:
/**
 * Instrument.java
 * @author Vagisha Sharma
 * Oct 28, 2009
 * @version 1.0
 */
package org.yeastrc.ms.domain.general.impl;

import org.yeastrc.ms.domain.general.MsInstrument;

/**
 *
 */
public class InstrumentBean implements MsInstrument {

    private int id;
    private String name;
    private String description;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>CSVParserTest</title>
<meta name="date" content="2015-01-12">
<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

org.deri.tarql

Class CSVParserTest

java.lang.Object

org.deri.tarql.CSVParserTest

public class CSVParserTest
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description

CSVParserTest()

Method Summary

Methods

Modifier and Type
Method and Description

private static long
countRows(java.lang.String csv,
         boolean varsFromHeader)

private static java.util.List<com.hp.hpl.jena.sparql.core.Var>
getNonPseudoVars(java.lang.String csv,
                boolean varsFromHeader)

private static CSVParser
readCSV(java.lang.String csv,
       boolean varsFromHeader)

private static CSVParser
readCSV(java.lang.String csv,
       boolean varsFromHeader,
       char escape)

private static CSVParser
readCSV(java.lang.String csv,
       boolean varsFromHeader,
       char delimiter,
       char quote)

void
testAssignNewNameToReservedColumnName()

void
testColumnName()

void
testCountVars()

void
testDuplicateColumnName()

void
testEmptyColumn()

void
testEscapingDelimiterWithBackslash()

void
testEscapingQuoteWithBackslash()

void
testFillAdditionalColumnsNotInHeader()

void
testFillNonColumnsInHeader()

void
testHandleClashWhenFillingInVarNames1()

void
testHandleClashWhenFillingInVarNames2()

void
testHandleDashesInColumnNames()

void
testHandleQuestionMarkInColumnNames()

void
testHandleSpacesInColumnNames()

void
testHeading()

void
testIncludesROWNUM()

void
testNoEmptyStrings()

void
testQuoteDoubling()

void
testSemicolonSeparated()

void
testSingleQuotes()

void
testSkipEmptyLines()

void
testSkipEmptyRowsBeforeHeader()

void
testStandardQuotes()

void
testTabSeparated()

void
testUnbound()

void
testWithHeaders()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CSVParserTest

public CSVParserTest()

Method Detail

testColumnName

public void testColumnName()

testCountVars

public void testCountVars()
                   throws java.io.IOException

Throws:

java.io.IOException

testHeading

public void testHeading()
                 throws java.io.IOException

Throws:

java.io.IOException

testUnbound

public void testUnbound()
                 throws java.io.IOException

Throws:

java.io.IOException

testNoEmptyStrings

public void testNoEmptyStrings()
                        throws java.io.IOException

Throws:

java.io.IOException

testSkipEmptyLines

public void testSkipEmptyLines()
                        throws java.io.IOException

Throws:

java.io.IOException

testWithHeaders

public void testWithHeaders()
                     throws java.io.IOException

Throws:

java.io.IOException

testSkipEmptyRowsBeforeHeader

public void testSkipEmptyRowsBeforeHeader()
                                   throws java.io.IOException

Throws:

java.io.IOException

testFillAdditionalColumnsNotInHeader

public void testFillAdditionalColumnsNotInHeader()
                                          throws java.io.IOException

Throws:

java.io.IOException

testFillNonColumnsInHeader

public void testFillNonColumnsInHeader()
                                throws java.io.IOException

Throws:

java.io.IOException

testHandleSpacesInColumnNames

public void testHandleSpacesInColumnNames()
                                   throws java.io.IOException

Throws:

java.io.IOException

testHandleDashesInColumnNames

public void testHandleDashesInColumnNames()
                                   throws java.io.IOException

Throws:

java.io.IOException

testHandleQuestionMarkInColumnNames

public void testHandleQuestionMarkInColumnNames()
                                         throws java.io.IOException

Throws:

java.io.IOException

testDuplicateColumnName

public void testDuplicateColumnName()
                             throws java.io.IOException

Throws:

java.io.IOException

testHandleClashWhenFillingInVarNames1

public void testHandleClashWhenFillingInVarNames1()
                                           throws java.io.IOException

Throws:

java.io.IOException

testHandleClashWhenFillingInVarNames2

public void testHandleClashWhenFillingInVarNames2()
                                           throws java.io.IOException

Throws:

java.io.IOException

testAssignNewNameToReservedColumnName

public void testAssignNewNameToReservedColumnName()
                                           throws java.io.IOException

Throws:

java.io.IOException

testIncludesROWNUM

public void testIncludesROWNUM()
                        throws java.io.IOException

Throws:

java.io.IOException

testEmptyColumn

public void testEmptyColumn()
                     throws java.io.IOException

Throws:

java.io.IOException

testTabSeparated

public void testTabSeparated()
                      throws java.io.IOException

Throws:

java.io.IOException

testSemicolonSeparated

public void testSemicolonSeparated()
                            throws java.io.IOException

Throws:

java.io.IOException

testStandardQuotes

public void testStandardQuotes()
                        throws java.io.IOException

Throws:

java.io.IOException

testSingleQuotes

public void testSingleQuotes()
                      throws java.io.IOException

Throws:

java.io.IOException

testQuoteDoubling

public void testQuoteDoubling()
                       throws java.io.IOException

Throws:

java.io.IOException

testEscapingQuoteWithBackslash

public void testEscapingQuoteWithBackslash()
                                    throws java.io.IOException

Throws:

java.io.IOException

testEscapingDelimiterWithBackslash

public void testEscapingDelimiterWithBackslash()
                                        throws java.io.IOException

Throws:

java.io.IOException

readCSV

private static CSVParser readCSV(java.lang.String csv,
                boolean varsFromHeader)
                          throws java.io.IOException

Throws:

java.io.IOException

readCSV

private static CSVParser readCSV(java.lang.String csv,
                boolean varsFromHeader,
                char delimiter,
                char quote)
                          throws java.io.IOException

Throws:

java.io.IOException

readCSV

private static CSVParser readCSV(java.lang.String csv,
                boolean varsFromHeader,
                char escape)
                          throws java.io.IOException

Throws:

java.io.IOException

countRows

private static long countRows(java.lang.String csv,
             boolean varsFromHeader)
                       throws java.io.IOException

Throws:

java.io.IOException

getNonPseudoVars

private static java.util.List<com.hp.hpl.jena.sparql.core.Var> getNonPseudoVars(java.lang.String csv,
                                                               boolean varsFromHeader)
                                                                         throws java.io.IOException

Throws:

java.io.IOException

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method


text:
#region License

// Distributed under the MIT License
// ============================================================
// Copyright (c) 2019 Hotcakes Commerce, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
// and associated documentation files (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge, publish, distribute,
// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or
// substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#endregion

using System.Collections.Generic;
using Hotcakes.CommerceDTO.v1.Catalog;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Hotcakes.CommerceDTO.Tests
{
    /// <summary>
    ///     This class is used to perform test against Product Options end points in REST API.
    /// </summary>
    [TestClass]
    public class ProductOptionsTests : ApiTestBase
    {
        /// <summary>
        ///     This method is used to test Find all Product Option end point.
        /// </summary>
        [TestMethod]
        public void ProductOption_FindAll()
        {
            var proxy = CreateApiProxy();

            var response = proxy.ProductOptionsFindAll();

            CheckErrors(response);

            var responseForProduct = proxy.ProductOptionsFindAllByProductId(TestConstants.TestProductBvin);

            CheckErrors(response);
        }

        /// <summary>
        ///     This method is used to test Create and Delete end point.
        /// </summary>
        [TestMethod]
        public void ProductOption_CreateAndDelete()
        {
            //Create API Proxy
            var proxy = CreateApiProxy();

            //Create Product Option
            var option = new OptionDTO
            {
                StoreId = 1,
                Name = "Html Option",
                OptionType = OptionTypesDTO.Html,
                Items = new List<OptionItemDTO>()
            };
            var createResponse = proxy.ProductOptionsCreate(option);
            CheckErrors(createResponse);

            //Find Product Option
            var findResponse = proxy.ProductOptionsFind(createResponse.Content.Bvin);
            CheckErrors(findResponse);
            Assert.AreEqual(createResponse.Content.Name, findResponse.Content.Name);
            Assert.AreEqual(createResponse.Content.StoreId, findResponse.Content.StoreId);

            //Update Product Option
            createResponse.Content.Name = option.Name + "updated";
            var updateResponse = proxy.ProductOptionsUpdate(createResponse.Content);
            CheckErrors(updateResponse);
            Assert.AreEqual(createResponse.Content.Name, updateResponse.Content.Name);

            //Delete Product Option
            var deleteResponse = proxy.ProductOptionsDelete(createResponse.Content.Bvin);
            Assert.IsTrue(deleteResponse.Content);
        }

        //This method is used to test Create and Assign to product end point.
        [TestMethod]
        public void ProductOption_CreateAndAssignToProduct()
        {
            //Create API Proxy
            var proxy = CreateApiProxy();

            //Create Production option
            var option = new OptionDTO
            {
                StoreId = 1,
                Name = "TEST Option",
                OptionType = OptionTypesDTO.DropDownList,
                Items = new List<OptionItemDTO>()
            };
            var createResponse = proxy.ProductOptionsCreate(option);
            CheckErrors(createResponse);

            //Assign product option to test product
            var assingtoProductResponse = proxy.ProductOptionsAssignToProduct(createResponse.Content.Bvin,
                TestConstants.TestProductBvin, false);
            Assert.IsTrue(assingtoProductResponse.Content);

            //Generate product variants for options
            var generateVariantsResponse = proxy.ProductOptionsGenerateAllVariants(TestConstants.TestProductBvin);
            Assert.IsTrue(generateVariantsResponse.Content);
        }

        //This method is used to test Assign and Unassign to product end point.
        [TestMethod]
        public void ProductOption_AssignAndUnassignToProduct()
        {
            //Create API Proxy
            var proxy = CreateApiProxy();

            //Create Production option
            var option = new OptionDTO
            {
                StoreId = 1,
                Name = "TEST Unassign Option",
                OptionType = OptionTypesDTO.DropDownList,
                Items = new List<OptionItemDTO>()
            };
            var createResponse = proxy.ProductOptionsCreate(option);
            CheckErrors(createResponse);

            //Assign product option to test product
            var assingtoProductResponse = proxy.ProductOptionsAssignToProduct(createResponse.Content.Bvin, TestConstants.TestProductBvin, false);
            Assert.IsTrue(assingtoProductResponse.Content);

            //Generate product variants for options
            var unassignFromProductResponse = proxy.ProductOptionsUnassignFromProduct(createResponse.Content.Bvin, TestConstants.TestProductBvin);
            Assert.IsTrue(unassignFromProductResponse.Content);
        }
    }
}


text:
namespace ORCore
{
    struct BufferInfo
    {
        int channels;
        int frames;
    };

    class Buffer
    {
    public:
        Buffer();
        Buffer(BufferInfo info);
        Buffer(float* buffer, BufferInfo info);
        Buffer(const Buffer& other);
        Buffer(Buffer&& other);
        ~Buffer();

        Buffer& operator=(const Buffer& other);
        Buffer& operator=(Buffer&& other);

        operator float*();

        void clone_type(const Buffer& other);

        BufferInfo get_info();
        int size();
        void clear();

    private:
        float* m_buffer;
        bool m_allocated;
        BufferInfo m_info;
        int m_size;
    };
}


text:
#ifndef VALUE_OF_H_included
#define VALUE_OF_H_included

#include "JNIHelp.h"

jobject booleanValueOf(JNIEnv* env, jboolean b);
jobject doubleValueOf(JNIEnv* env, jdouble d);
jobject integerValueOf(JNIEnv* env, jint i);
jobject longValueOf(JNIEnv* env, jlong l);

// Note that these aren't equivalent to the Number methods: the jobject MUST be of the exact
// type specified. This is less general but faster (and currently sufficient).
jboolean booleanValue(JNIEnv* env, jobject javaLangBoolean);
jint intValue(JNIEnv* env, jobject javaLangInteger);

#endif  // VALUE_OF_H_included


text:
import codecs
import datetime
import decimal

try:
    from collections import OrderedDict
    import json
except ImportError:
    from ordereddict import OrderedDict
    import simplejson as json

import agate
import six

from csvkit.cli import CSVKitUtility, match_column_identifier

class CSVJSON(CSVKitUtility):
    description = 'Convert a CSV file into JSON (or GeoJSON).'
    buffers_input = True

    def add_arguments(self):
        self.argparser.add_argument('-i', '--indent', dest='indent', type=int, default=None,
                                    help='Indent the output JSON this many spaces. Disabled by default.')
        self.argparser.add_argument('-k', '--key', dest='key', type=str, default=None,
                                    help='Output JSON as an array of objects keyed by a given column, KEY, rather than as a list. All values in the column must be unique. If --lat and --lon are also specified, this column will be used as GeoJSON Feature ID.')
        self.argparser.add_argument('--lat', dest='lat', type=str, default=None,
                                    help='A column index or name containing a latitude. Output will be GeoJSON instead of JSON. Only valid if --lon is also specified.')
        self.argparser.add_argument('--lon', dest='lon', type=str, default=None,
                                    help='A column index or name containing a longitude. Output will be GeoJSON instead of JSON. Only valid if --lat is also specified.')
        self.argparser.add_argument('--crs', dest='crs', type=str, default=None,
                                    help='A coordinate reference system string to be included with GeoJSON output. Only valid if --lat and --lon are also specified.')
        self.argparser.add_argument('--stream', dest='streamOutput', action='store_true',
                                    help='Output JSON as a stream of newline-separated objects, rather than an as an array.')
        self.argparser.add_argument('-y', '--snifflimit', dest='sniff_limit', type=int,
                                    help='Limit CSV dialect sniffing to the specified number of bytes. Specify "0" to disable sniffing entirely.')
        self.argparser.add_argument('-I', '--no-inference', dest='no_inference', action='store_true',
                                    help='Disable type inference (and --locale, --date-format, --datetime-format) when parsing CSV input.')

    def main(self):
        # We need to do this dance here, because we aren't writing through agate.
        if six.PY2:
            stream = codecs.getwriter('utf-8')(self.output_file)
        else:
            stream = self.output_file

        json_kwargs = {
            'ensure_ascii': False,
            'indent': self.args.indent,
        }

        if six.PY2:
            json_kwargs['encoding'] = 'utf-8'

        def default(obj):
            if isinstance(obj, (datetime.date, datetime.datetime)):
                return obj.isoformat()
            elif isinstance(obj, decimal.Decimal):
                return str(obj)
            raise TypeError('%s is not JSON serializable' % repr(obj))

        def dump_json(data, newline=False):
            json.dump(data, stream, default=default, **json_kwargs)
            if newline:
                stream.write("\n")

        """
        Convert CSV to JSON.
        """
        if self.args.lat and not self.args.lon:
            self.argparser.error('--lon is required whenever --lat is specified.')

        if self.args.lon and not self.args.lat:
            self.argparser.error('--lat is required whenever --lon is specified.')

        if self.args.crs and not self.args.lat:
            self.argparser.error('--crs is only allowed when --lat and --lon are also specified.')

        if self.args.streamOutput and (self.args.lat or self.args.lon or self.args.key):
            self.argparser.error('--stream is only allowed if --lat, --lon and --key are not specified.')

        # GeoJSON
        if self.args.lat and self.args.lon:
            table = agate.Table.from_csv(
                self.input_file,
                skip_lines=self.args.skip_lines,
                sniff_limit=self.args.sniff_limit,
                column_types=self.get_column_types(),
                **self.reader_kwargs
            )

            features = []
            min_lon = None
            min_lat = None
            max_lon = None
            max_lat = None

            lat_column = match_column_identifier(table.column_names, self.args.lat, self.args.zero_based)
            lon_column = match_column_identifier(table.column_names, self.args.lon, self.args.zero_based)

            if self.args.key:
                id_column = match_column_identifier(table.column_names, self.args.key, self.args.zero_based)
            else:
                id_column = None

            for row in table.rows:
                feature = OrderedDict()
                feature['type'] = 'Feature'
                properties = OrderedDict()
                geoid = None
                lat = None
                lon = None

                for i, c in enumerate(row):
                    if i == lat_column:
                        try:
                            lat = float(c)
                        except ValueError:
                            lat = None
                        if min_lat is None or lat < min_lat:
                            min_lat = lat
                        if max_lat is None or lat > max_lat:
                            max_lat = lat
                    elif i == lon_column:
                        try:
                            lon = float(c)
                        except ValueError:
                            lon = None
                        if min_lon is None or lon < min_lon:
                            min_lon = lon
                        if max_lon is None or lon > max_lon:
                            max_lon = lon
                    elif i == id_column:
                        geoid = c
                    else:
                        properties[table.column_names[i]] = c

                if id_column is not None:
                    feature['id'] = geoid

                feature['geometry'] = OrderedDict([
                    ('type', 'Point'),
                    ('coordinates', [lon, lat])
                ])
                feature['properties'] = properties
                features.append(feature)

            output = OrderedDict([
                ('type', 'FeatureCollection'),
                ('bbox', [min_lon, min_lat, max_lon, max_lat]),
                ('features', features)
            ])

            if self.args.crs:
                output['crs'] = OrderedDict([
                    ('type', 'name'),
                    ('properties', {
                        'name': self.args.crs
                    })
                ])

            dump_json(output)
        elif self.args.streamOutput and self.args.no_inference and not self.args.skip_lines:
            rows = agate.csv.reader(self.input_file, **self.reader_kwargs)
            column_names = next(rows)

            for row in rows:
                data = OrderedDict()
                for i, column in enumerate(column_names):
                    try:
                        data[column] = row[i]
                    except IndexError:
                        data[column] = None
                dump_json(data, newline=True)
        else:
            table = agate.Table.from_csv(
                self.input_file,
                skip_lines=self.args.skip_lines,
                sniff_limit=self.args.sniff_limit,
                column_types=self.get_column_types(),
                **self.reader_kwargs
            )

            table.to_json(
                self.output_file,
                key=self.args.key,
                newline=self.args.streamOutput,
                indent=self.args.indent
            )

def launch_new_instance():
    utility = CSVJSON()
    utility.run()

if __name__ == '__main__':
    launch_new_instance()


text:
package org.apache.activemq.openwire.codec.universal;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.activemq.openwire.codec.*;
import org.apache.activemq.openwire.commands.*;

/**
 * Marshalling code for Open Wire for RemoveSubscriptionInfo
 *
 * NOTE!: This file is auto generated - do not modify!
 *
 */
public class RemoveSubscriptionInfoMarshaller extends BaseCommandMarshaller {

    /**
     * Return the type of Data Structure handled by this Marshaler
     *
     * @return short representation of the type data structure
     */
    public byte getDataStructureType() {
        return RemoveSubscriptionInfo.DATA_STRUCTURE_TYPE;
    }

    /**
     * @return a new instance of the managed type.
     */
    public DataStructure createObject() {
        return new RemoveSubscriptionInfo();
    }

    /**
     * Un-marshal an object instance from the data input stream
     *
     * @param wireFormat the OpenWireFormat instance to use
     * @param target the object to un-marshal
     * @param dataIn the data input stream to build the object from
     * @param bs the boolean stream where the type's booleans were marshaled
     *
     * @throws IOException if an error occurs while reading the data
     */
    public void tightUnmarshal(OpenWireFormat wireFormat, Object target, DataInput dataIn, BooleanStream bs) throws IOException {
        super.tightUnmarshal(wireFormat, target, dataIn, bs);

        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo) target;

        info.setConnectionId((ConnectionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
        info.setSubscriptionName(tightUnmarshalString(dataIn, bs));
        info.setClientId(tightUnmarshalString(dataIn, bs));
    }

    /**
     * Write the booleans that this object uses to a BooleanStream
     *
     * @param wireFormat the OpenWireFormat instance to use
     * @param source the object to marshal
     * @param bs the boolean stream where the type's booleans are written
     *
     * @throws IOException if an error occurs while writing the data
     */
    public int tightMarshal1(OpenWireFormat wireFormat, Object source, BooleanStream bs) throws IOException {
        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo) source;

        int rc = super.tightMarshal1(wireFormat, source, bs);
        rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getConnectionId(), bs);
        rc += tightMarshalString1(info.getSubscriptionName(), bs);
        rc += tightMarshalString1(info.getClientId(), bs);

        return rc + 0;
    }

    /**
     * Write a object instance to data output stream
     *
     * @param wireFormat the OpenWireFormat instance to use
     * @param source the object to marshal
     * @param dataOut the DataOut where the properties are written
     * @param bs the boolean stream where the type's booleans are written
     *
     * @throws IOException if an error occurs while writing the data
     */
    public void tightMarshal2(OpenWireFormat wireFormat, Object source, DataOutput dataOut, BooleanStream bs) throws IOException {
        super.tightMarshal2(wireFormat, source, dataOut, bs);

        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo) source;

        tightMarshalCachedObject2(wireFormat, (DataStructure)info.getConnectionId(), dataOut, bs);
        tightMarshalString2(info.getSubscriptionName(), dataOut, bs);
        tightMarshalString2(info.getClientId(), dataOut, bs);
    }

    /**
     * Write the object to the output using loose marshaling.
     *
     * @throws IOException if an error occurs while writing the data
     */
    public void looseMarshal(OpenWireFormat wireFormat, Object source, DataOutput dataOut) throws IOException {
        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo) source;

        super.looseMarshal(wireFormat, source, dataOut);
        looseMarshalCachedObject(wireFormat, (DataStructure)info.getConnectionId(), dataOut);
        looseMarshalString(info.getSubscriptionName(), dataOut);
        looseMarshalString(info.getClientId(), dataOut);
    }

    /**
     * Un-marshal an object instance from the data input stream
     *
     * @param target the object to un-marshal
     * @param dataIn the data input stream to build the object from
     *
     * @throws IOException if an error occurs while writing the data
     */
    public void looseUnmarshal(OpenWireFormat wireFormat, Object target, DataInput dataIn) throws IOException {
        super.looseUnmarshal(wireFormat, target, dataIn);

        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo) target;

        info.setConnectionId((ConnectionId) looseUnmarsalCachedObject(wireFormat, dataIn));
        info.setSubscriptionName(looseUnmarshalString(dataIn));
        info.setClientId(looseUnmarshalString(dataIn));
    }
}


text:
Title: Comic #3
Date: 2016-10-22 00:30
Category: Comic

<img src="{filename}/images/comic3.jpg" alt="I know I misspelled something" title="I know I misspelled something" style="max-width: 100%;height: auto;"/>


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

<resources xmlns:tools="http://schemas.android.com/tools">
    <!-- Base application theme. -->
    <style name="Theme.Datastore" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
        <!-- Primary brand color. -->
        <item name="colorPrimary">@color/purple_200</item>
        <item name="colorPrimaryVariant">@color/purple_700</item>
        <item name="colorOnPrimary">@color/black</item>
        <!-- Secondary brand color. -->
        <item name="colorSecondary">@color/teal_200</item>
        <item name="colorSecondaryVariant">@color/teal_200</item>
        <item name="colorOnSecondary">@color/white</item>
        <!-- Status bar color. -->
        <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
        <!-- Customize your theme here. -->
    </style>
</resources>


text:
title: Accordion
description: Accordions are elements that help you organize and navigate multiple documents in a single container. They can be used for switching between items in the container.
sass: scss/components/_accordion.scss
js: js/foundation.accordion.js
---

## Basics

The container for an accordion needs the class `.accordion`, and the attribute `data-accordion`. Note that in these examples, we use a `<ul>`, but you can use any element you want.

```html
<ul class="accordion" data-accordion></ul>
```

Inside the accordion, place a series of panes with the class `.accordion-item` and the attribute `data-accordion-item`. To mark which pane should be open by default, add the class `.is-active` to that pane.

Each pane has a **title**, an `<a>` with the class `.accordion-title`, and a **content area**, an element with the class `.accordion-content` and the attribute `data-tab-content`.

```html
<ul class="accordion" data-accordion>
  <li class="accordion-item is-active" data-accordion-item>
    <!-- Accordion tab title -->
    <a href="#" class="accordion-title">Accordion 1</a>

    <!-- Accordion tab content: it would start in the open state due to using the `is-active` state class. -->
    <div class="accordion-content" data-tab-content>
      <p>Panel 1. Lorem ipsum dolor</p>
      <a href="#">Nowhere to Go</a>
    </div>
  </li>
  <!-- ... -->
</ul>
```

Once you put it all together, here's what you get!

    Accordion 1

Panel 1. Lorem ipsum dolor

      Nowhere to Go

    Accordion 2

      <textarea></textarea>
      <button class="button">I do nothing!</button>

    Accordion 3

      Type your name!
      <input type="text"></input>

---

## Advanced Options

### Multi-expand

By default, only one pane of an accordion can be open at a time. This can be changed by setting the `multiExpand` option to `true`.

```html
<ul class="accordion" data-accordion data-multi-expand="true">
  <!-- ... -->
</ul>
```

    Accordion 1

      Panel 1. Lorem ipsum dolor

    Accordion 2

      Panel 2. Lorem ipsum dolor

    Accordion 3

      Panel 3. Lorem ipsum dolor

---

### All Closed

By default, at least one pane in an accordion must be open. This can be changed by setting `allowAllClosed` option to `true`.

```html
<ul class="accordion" data-accordion data-allow-all-closed="true">
  <!-- ... -->
</ul>
```

    Accordion 1

      Panel 1. Lorem ipsum dolor

    Accordion 2

      Panel 2. Lorem ipsum dolor

    Accordion 3

      Panel 3. Lorem ipsum dolor

---

### Disabled

There may be times where you want to disable pane switching on an accordion. This can be accomplished by setting the `disabled` option.

The `disabled` option disables all up, down, and toggle methods of an accordion.  If you wish to manipulate a disabled accordion with JavaScript, you will need to remove the `disabled` option from the accordion.

```html_example
<ul class="accordion" data-accordion disabled>
  <li class="accordion-item is-active" data-accordion-item>
    <a href="#" class="accordion-title">Accordion 1</a>
    <div class="accordion-content" data-tab-content>
      Panel 1. I'm open because I'm loaded that way, but you can't close me
    </div>
  </li>
  <li class="accordion-item" data-accordion-item>
    <a href="#" class="accordion-title">Accordion 2, you can't open me.</a>
    <div class="accordion-content" data-tab-content>
      Panel 2. Lorem ipsum dolor
    </div>
  </li>
  <li class="accordion-item" data-accordion-item>
    <a href="#" class="accordion-title">Accordion 3, you can't open me.</a>
    <div class="accordion-content" data-tab-content>
      Panel 3. Lorem ipsum dolor
    </div>
  </li>
</ul>
```
---

## Accordion and URLs

### Browser history

When the `data-deep-link` option is set to `true`, the current state of the accordion is recorded by adding a hash with the accordion panel ID to the browser URL when a accordion opens. By default, accordion *replace* the browser history (using `history.replaceState()`). Modify this behavior by using attribute `data-update-history="true"` to *append* to the browser history (using `history.pushState()`). In the latter case the browser back button will track each click that opens a accordion panel.

By using deep linking (see below), the open state of a page's tabset may be shared by copy-pasting the browser URL.

### Deep linking

Add the attribute `data-deep-link="true"` to a accordion to:
- modify the browser history when a accordion panel is clicked
- allow users to open a particular accordion panel at page load with a hash-appended URL

```html_example
<ul class="accordion" data-accordion data-deep-link="true" data-update-history="true" data-deep-link-smudge="true" data-deep-link-smudge="500" id="deeplinked-accordion">
  <li class="accordion-item is-active" data-accordion-item>
    <a href="#deeplink1" class="accordion-title">Accordion 1</a>
    <div class="accordion-content" data-tab-content id="deeplink1">
      Panel 1. Lorem ipsum dolor
    </div>
  </li>
  <li class="accordion-item" data-accordion-item>
    <a href="#deeplink2" class="accordion-title">Accordion 2</a>
    <div class="accordion-content" data-tab-content id="deeplink2">
      Panel 2. Lorem ipsum dolor
    </div>
  </li>
  <li class="accordion-item" data-accordion-item>
    <a href="#deeplink3" class="accordion-title">Accordion 3</a>
    <div class="accordion-content" data-tab-content id="deeplink3">
      Panel 3. Lorem ipsum dolor
    </div>
  </li>
</ul>
```
For example, http://example.com/#deeplink3 will open the third accordion panel at page load. This example will open a new browser tab and scroll you to the open accordion panel.

When linking directly to a accordion panel, it might not be obvious that the content appears within a accordion panel. An additional attribute `data-deep-link-smudge` rolls the page up slightly after deep linking (to a horizontal accordion) so that the accordion is at the top of the viewport.

```html_example
<ul class="accordion" data-deep-link="true" data-deep-link-smudge="true" data-deep-link-smudge-delay="600" data-accordion id="deeplinked-accordion-with-smudge">
```


text:
var AnnotationToolMixin = require("./annotation_tool_mixin");

var StrongTool = React.createClass({
  // TODO: try dis!
  // splitContainerSelections: true,
  mixins: [AnnotationToolMixin],
  displayName: "StrongTool",
  title: "Strong",
  annotationType: "strong",
  toolIcon: "fa-bold",
});

module.exports = StrongTool;


text:
/**@file tsip_header_P_Access_Network_Info.h
 * @brief SIP header 'P-Access-Network-Info'.
 *
 * @author Mamadou Diop <diopmamadou(at)doubango[dot]org>
 *

 */
#ifndef _TSIP_HEADER_P_ACCESS_NETWORK_INFO_H_
#define _TSIP_HEADER_P_ACCESS_NETWORK_INFO_H_

#include "tinysip_config.h"
#include "tinysip/headers/tsip_header.h"

TSIP_BEGIN_DECLS

#define TSIP_HEADER_P_ACCESS_NETWORK_INFO_VA_ARGS(value)	tsip_header_P_Access_Network_Info_def_t, (const char*)value

////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// @brief	SIP header 'P-Access-Network-Info' as per RFC 3455.
///
/// @par ABNF: P-Access-Network-Info  	= 	"P-Access-Network-Info" HCOLON access-net-spec
/// access-net-spec	= 	access-type *( SEMI access-info )
/// access-type	= 	"IEEE-802.11a" / "IEEE-802.11b" / "3GPP-GERAN" / "3GPP-UTRAN-FDD" / "3GPP-UTRAN-TDD" / "3GPP-CDMA2000" / token
/// access-info	= 	cgi-3gpp / utran-cell-id-3gpp / extension-access-info
/// extension-access-info	= 	gen-value
/// cgi-3gpp	= 	"cgi-3gpp" EQUAL (token / quoted-string)
/// utran-cell-id-3gpp	= 	"utran-cell-id-3gpp" EQUAL (token / quoted-string)
///
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct tsip_header_P_Access_Network_Info_s
{
	TSIP_DECLARE_HEADER;

	char *value;
}
tsip_header_P_Access_Network_Info_t;

TINYSIP_API tsip_header_P_Access_Network_Info_t* tsip_header_P_Access_Network_Info_create(const char* value);
TINYSIP_API tsip_header_P_Access_Network_Info_t* tsip_header_P_Access_Network_Info_create_null();

TINYSIP_API tsip_header_P_Access_Network_Info_t *tsip_header_P_Access_Network_Info_parse(const char *data, tsk_size_t size);

TINYSIP_GEXTERN const tsk_object_def_t *tsip_header_P_Access_Network_Info_def_t;

TSIP_END_DECLS

#endif /* _TSIP_HEADER_P_ACCESS_NETWORK_INFO_H_ */


text:
package com.vaadin.tests.components.panel;

import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.Panel;
import com.vaadin.ui.VerticalLayout;

public class PanelChangeContents extends AbstractTestUI implements
        ClickListener {

    VerticalLayout stats = new VerticalLayout();
    VerticalLayout companies = new VerticalLayout();
    VerticalLayout settings = new VerticalLayout();

    Button statsButton = new Button("Stats", this);
    Button companiesButton = new Button("Companies", this);
    Button settingsButton = new Button("Settings", this);

    private Panel panel;

    @Override
    protected void setup(VaadinRequest request) {
        VerticalLayout content = new VerticalLayout();
        setSizeFull();
        HorizontalLayout buttons = new HorizontalLayout();
        stats.addComponent(new Label("stats"));
        companies.addComponent(new Label("companies"));
        settings.addComponent(new Label("settings"));
        buttons.addComponent(statsButton);
        buttons.addComponent(companiesButton);
        buttons.addComponent(settingsButton);
        panel = new Panel();
        panel.setSizeFull();
        panel.setContent(stats);
        content.addComponent(buttons);
        content.addComponent(panel);
        content.setMargin(true);
        content.setSpacing(true);
        content.setExpandRatio(panel, 1);
        setContent(content);
    }

    @Override
    public void buttonClick(ClickEvent event) {
        if (event.getButton() == statsButton) {
            panel.setContent(stats);
        } else if (event.getButton() == companiesButton) {
            panel.setContent(companies);
        } else if (event.getButton() == settingsButton) {
            panel.setContent(settings);
        }

    }

    @Override
    protected String getTestDescription() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    protected Integer getTicketNumber() {
        return 8735;
    }

}


text:
package mesosphere.marathon.event.http

import akka.actor.{ Actor, ActorLogging }
import akka.pattern.pipe
import mesosphere.marathon.event.http.SubscribersKeeperActor._
import mesosphere.marathon.event.{ MarathonSubscriptionEvent, Subscribe, Unsubscribe }
import mesosphere.marathon.state.EntityStore

import scala.concurrent.Future

class SubscribersKeeperActor(val store: EntityStore[EventSubscribers]) extends Actor with ActorLogging {

  implicit val ec = HttpEventModule.executionContext

  override def receive: Receive = {

    case event @ Subscribe(_, callbackUrl, _, _) =>
      val addResult: Future[EventSubscribers] = add(callbackUrl)

      val subscription: Future[MarathonSubscriptionEvent] =
        addResult.map { subscribers =>
          if (subscribers.urls.contains(callbackUrl))
            log.info("Callback [%s] subscribed." format callbackUrl)
          event
        }

      subscription pipeTo sender()

    case event @ Unsubscribe(_, callbackUrl, _, _) =>
      val removeResult: Future[EventSubscribers] = remove(callbackUrl)

      val subscription: Future[MarathonSubscriptionEvent] =
        removeResult.map { subscribers =>
          if (!subscribers.urls.contains(callbackUrl))
            log.info("Callback [%s] unsubscribed." format callbackUrl)
          event
        }

      subscription pipeTo sender()

    case GetSubscribers =>
      val subscription = store.fetch(Subscribers).map(_.getOrElse(EventSubscribers()))

      subscription pipeTo sender()
  }

  protected[this] def add(callbackUrl: String): Future[EventSubscribers] =
    store.modify(Subscribers) { deserialize =>
      val existingSubscribers = deserialize()
      if (existingSubscribers.urls.contains(callbackUrl)) {
        log.info("Existing callback [%s] resubscribed." format callbackUrl)
        existingSubscribers
      }
      else EventSubscribers(existingSubscribers.urls + callbackUrl)
    }

  protected[this] def remove(callbackUrl: String): Future[EventSubscribers] =
    store.modify(Subscribers) { deserialize =>
      val existingSubscribers = deserialize()

      if (existingSubscribers.urls.contains(callbackUrl))
        EventSubscribers(existingSubscribers.urls - callbackUrl)

      else {
        log.warning("Attempted to unsubscribe nonexistent callback [%s]." format callbackUrl)
        existingSubscribers
      }
    }
}

object SubscribersKeeperActor {

  case object GetSubscribers

  final val Subscribers = "http_event_subscribers"
}


text:
<?xml version="1.0"?>
<!--
# -*- coding: utf-8 -*-
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
-->
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
  <property>
    <name>jvm.config</name>
    <value>-server
-Xmx16G
-XX:+UseG1GC
-XX:+UseGCOverheadLimit
-XX:+ExplicitGCInvokesConcurrent
-XX:+HeapDumpOnOutOfMemoryError
-XX:OnOutOfMemoryError=kill -9 %p</value>
    <description>
       A list of command line options used for launching the Java Virtual
       Machine. The format of the file must be one option per line. These
       options are not interpreted by the shell, so options containing spaces or
       other special characters should not be quoted (as demonstrated by the
       OnOutOfMemoryError option).
    </description>
  </property>
</configuration>


text:
layout: post
title: hardcore mouth and ass fucking with sperm from ass DeNata
titleinfo: pornvd
desc: Watch hardcore mouth and ass fucking with sperm from ass DeNata. Pornhub is the ultimate xxx porn and sex site.
---

hardcore mouth and ass fucking with sperm from ass DeNata

Watch hardcore mouth and ass fucking with sperm from ass DeNata. Pornhub is the ultimate xxx porn and sex site.


text:
package jwtclaim

import (
	"crypto/subtle"
	"time"
)

// Key constants define the main claims used for Set() and Get() functions.
// Those constants are implemented in the StandardClaims type.
const (
	KeyAudience  = "aud"
	KeyExpiresAt = "exp"
	KeyID        = "jti"
	KeyIssuedAt  = "iat"
	KeyIssuer    = "iss"
	KeyNotBefore = "nbf"
	KeySubject   = "sub"
	KeyTimeSkew  = "skew" // not marshalled, internal usage.
)

// allKeys first seven entries only supported by Standard type and all entries
// supported by Store type.
var allKeys = [9]string{KeyAudience, KeyExpiresAt, KeyID, KeyIssuedAt, KeyIssuer, KeyNotBefore, KeySubject, KeyStore, KeyUserID}

// TimeFunc provides the current time when parsing token to validate "exp" claim
// (expiration time). You can override it to use another time value.  This is
// useful for testing or if your server uses a different time zone than your
// tokens.
var TimeFunc = time.Now

func verifyConstantTime(aud, cmp []byte, required bool) bool {
	if len(aud) == 0 {
		return !required
	}
	return subtle.ConstantTimeCompare(aud, cmp) == 1
}

func verifyExp(skew time.Duration, exp, now int64, required bool) bool {
	if exp == 0 {
		return !required
	}
	now -= int64(skew.Seconds())
	return now <= exp
}

func verifyIat(iat int64, now int64, required bool) bool {
	if iat == 0 {
		return !required
	}
	return now >= iat
}

func verifyNbf(skew time.Duration, nbf int64, now int64, required bool) bool {
	if nbf == 0 {
		return !required
	}
	now += int64(skew.Seconds())
	return now >= nbf
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--

    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You under the Apache License, Version 2.0
    (the "License"); you may not use this file except in compliance with
    the License.  You may obtain a copy of the License at

         http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
    ">

    <camelContext id="camel-C" xmlns="http://camel.apache.org/schema/spring">

        <propertyPlaceholder id="properties" location="org/apache/camel/spring/config/pool.properties"/>

        <!-- define a low profile -->
        <threadPoolProfile id="low"
                           poolSize="{{low.min}}"
                           maxPoolSize="{{low.max}}"/>

        <!-- define a big profile with many threads -->
        <threadPoolProfile id="big"
                           poolSize="{{big.min}}"
                           maxPoolSize="{{big.max}}" rejectedPolicy="DiscardOldest"/>

        <route>
            <from uri="direct:start"/>
            <threads/>
            <to uri="mock:result"/>
        </route>

    </camelContext>

</beans>


text:
use Bin;
use Buildable;
use Container;
use ToolItem;
use Widget;
use ffi;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::SignalHandlerId;
use glib::signal::connect_raw;
use glib::translate::*;
use glib_ffi;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib_wrapper! {
    pub struct SeparatorToolItem(Object<ffi::GtkSeparatorToolItem, ffi::GtkSeparatorToolItemClass, SeparatorToolItemClass>) @extends ToolItem, Bin, Container, Widget, @implements Buildable;

    match fn {
        get_type => || ffi::gtk_separator_tool_item_get_type(),
    }
}

impl SeparatorToolItem {
    pub fn new() -> SeparatorToolItem {
        assert_initialized_main_thread!();
        unsafe {
            ToolItem::from_glib_none(ffi::gtk_separator_tool_item_new()).unsafe_cast()
        }
    }
}

impl Default for SeparatorToolItem {
    fn default() -> Self {
        Self::new()
    }
}

pub const NONE_SEPARATOR_TOOL_ITEM: Option<&SeparatorToolItem> = None;

pub trait SeparatorToolItemExt: 'static {
    fn get_draw(&self) -> bool;

    fn set_draw(&self, draw: bool);

    fn connect_property_draw_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<SeparatorToolItem>> SeparatorToolItemExt for O {
    fn get_draw(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_separator_tool_item_get_draw(self.as_ref().to_glib_none().0))
        }
    }

    fn set_draw(&self, draw: bool) {
        unsafe {
            ffi::gtk_separator_tool_item_set_draw(self.as_ref().to_glib_none().0, draw.to_glib());
        }
    }

    fn connect_property_draw_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(self.as_ptr() as *mut _, b"notify::draw\0".as_ptr() as *const _,
                Some(transmute(notify_draw_trampoline::<Self, F> as usize)), Box_::into_raw(f))
        }
    }
}

unsafe extern "C" fn notify_draw_trampoline<P, F: Fn(&P) + 'static>(this: *mut ffi::GtkSeparatorToolItem, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer)
where P: IsA<SeparatorToolItem> {
    let f: &F = transmute(f);
    f(&SeparatorToolItem::from_glib_borrow(this).unsafe_cast())
}

impl fmt::Display for SeparatorToolItem {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "SeparatorToolItem")
    }
}


text:
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using Inbox2.Channels.Imap2;
using Inbox2.Channels.Smtp;
using Inbox2.Platform.Channels.Configuration;
using Inbox2.Platform.Framework.Extensions;
using Inbox2.Platform.Interfaces.Enumerations;

namespace Inbox2.Channels.Other
{
    [Serializable]
    [Export(typeof(ChannelConfiguration))]
    public class OtherConfiguration : ChannelConfiguration
    {
        public OtherConfiguration()
        {
            InnerInputChannel = new Channel { MaxConcurrentConnections = 1 };
            InnerOutputChannel = new Channel { Type = typeof(SmtpClientChannel), MaxConcurrentConnections = 1 };
        }

        public override string DisplayName
        {
            get { return "Other"; }
        }

        public override DisplayStyle DisplayStyle
        {
            get { return DisplayStyle.Other; }
        }

		public override ChannelCharasteristics Charasteristics
		{
			get
			{
				var baseChars = ChannelCharasteristics.Default;

				if (InnerInputChannel != null)
					baseChars.SupportsReadStates =
						(InnerInputChannel.TypeSurrogate != null && InnerInputChannel.Type == typeof(Imap2ClientChannel));

				return baseChars;
			}
		}

        public override ChannelConfiguration Clone()
        {
            return this.DeepCopy(new XmlSerializer(typeof(OtherConfiguration)));
        }
    }
}


text:
(function() {
  var AnnouncementSigGen, BaseSigGen, CoinbaseProofGen, CryptocurrencySigGen, DnsProofGen, E, GenericWebSiteProofGen, GithubProofGen, HackerNewsProofGen, KeybaseProofGen, KeybasePushProofGen, RedditProofGen, RevokeProofSigGen, SignatureEngine, SocialNetworkProofGen, TrackerProofGen, TwitterProofGen, UntrackerProofGen, colors, constants, decode, env, iced, log, make_esc, master_ring, proofs, req, scrapers, session, strip_at, url_reencode, urlmod, __iced_k, __iced_k_noop,
    __hasProp = {}.hasOwnProperty,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

  iced = require('iced-runtime').iced;
  __iced_k = __iced_k_noop = function() {};

  proofs = require('keybase-proofs');

  make_esc = require('iced-error').make_esc;

  req = require('./req');

  constants = require('./constants').constants;

  session = require('./session');

  env = require('./env').env;

  log = require('./log');

  master_ring = require('./keyring').master_ring;

  decode = require('pgp-utils').armor.decode;

  colors = require('./colors');

  E = require('./err').E;

  req = require('./req');

  urlmod = require('url');

  scrapers = require('./scrapers');

  url_reencode = function(url) {
    var pad2;
    pad2 = function(x) {
      if (x.length === 1) {
        return "0" + x;
      } else {
        return x;
      }
    };
    return url.replace(/%20/g, '+').replace(/[()']/g, function(c) {
      return "%" + pad2(c.charCodeAt(0).toString(16));
    });
  };

  BaseSigGen = (function() {
    function BaseSigGen(_arg) {
      this.km = _arg.km, this.eldest_kid = _arg.eldest_kid, this.client = _arg.client, this.supersede = _arg.supersede, this.merkle_root = _arg.merkle_root, this.revoke_sig_ids = _arg.revoke_sig_ids;
    }

    BaseSigGen.prototype._get_seqno_type = function() {
      return "PUBLIC";
    };

    BaseSigGen.prototype._get_announce_number = function(cb) {
      var body, err, type, ___iced_passed_deferral, __iced_deferrals, __iced_k;
      __iced_k = __iced_k_noop;
      ___iced_passed_deferral = iced.findDeferral(arguments);
      type = this._get_seqno_type();
      (function(_this) {
        return (function(__iced_k) {
          __iced_deferrals = new iced.Deferrals(__iced_k, {
            parent: ___iced_passed_deferral,
            filename: "/home/jacko/node-client/src/sigs.iced",
            funcname: "BaseSigGen._get_announce_number"
          });
          req.get({
            endpoint: "sig/next_seqno",
            args: {
              type: type
            }
          }, __iced_deferrals.defer({
            assign_fn: (function() {
              return function() {
                err = arguments[0];
                return body = arguments[1];
              };
            })(),
            lineno: 40
          }));
          __iced_deferrals._fulfill();
        });
      })(this)((function(_this) {
        return function() {
          if (typeof err === "undefined" || err === null) {
            _this.seqno = body.seqno;
            _this.prev = body.prev;
          }
          return cb(err);
        };
      })(this));
    };

    BaseSigGen.prototype._get_binding_eng = function() {
      var arg, sig_ids;
      arg = {
        sig_eng: new SignatureEngine({
          km: this.km
        }),
        seqno: this.seqno,
        prev: this.prev,
        host: constants.canonical_host,
        user: {
          local: {
            uid: session.get_uid(),
            username: env().get_username()
          }
        },
        client: this.client,
        merkle_root: this.merkle_root,
        eldest_kid: this.eldest_kid
      };
      if ((sig_ids = this.revoke_sig_ids) != null) {
        arg.revoke = {
          sig_ids: sig_ids
        };
      }
      return this._make_binding_eng(arg);
    };

    BaseSigGen.prototype._do_signature = function(cb) {
      var err, ___iced_passed_deferral, __iced_deferrals, __iced_k;
      __iced_k = __iced_k_noop;
      ___iced_passed_deferral = iced.findDeferral(arguments);
      this.eng = this._get_binding_eng();
      (function(_this) {
        return (function(__iced_k) {
          __iced_deferrals = new iced.Deferrals(__iced_k, {
            parent: ___iced_passed_deferral,
            filename: "/home/jacko/node-client/src/sigs.iced",
            funcname: "BaseSigGen._do_signature"
          });
          _this.eng.generate(__iced_deferrals.defer({
            assign_fn: (function(__slot_1) {
              return function() {
                err = arguments[0];
                return __slot_1.sig = arguments[1];
              };
            })(_this),
            lineno: 70
          }));
          __iced_deferrals._fulfill();
        });
      })(this)((function(_this) {
        return function() {
          return cb(err);
        };
      })(this));
    };

    BaseSigGen.prototype._v_modify_store_arg = function(arg) {};

    BaseSigGen.prototype._get_api_endpoint = function() {
      return "sig/post";
    };

    BaseSigGen.prototype.expect_proof_text = function() {
      return false;
    };

    BaseSigGen.prototype._store_signature = function(cb) {
      var args, body, endpoint, err, ___iced_passed_deferral, __iced_deferrals, __iced_k;
      __iced_k = __iced_k_noop;
      ___iced_passed_deferral = iced.findDeferral(arguments);
      args = {
        sig: this.sig.pgp,
        sig_id_base: this.sig.id,
        sig_id_short: this.sig.short_id,
        is_remote_proof: true,
        supersede: this.supersede
      };
      this._v_modify_store_arg(args);
      endpoint = this._get_api_endpoint();
      log.debug("+ storing signature:");
      log.debug("| writing to " + endpoint);
      log.debug("| with args " + (JSON.stringify(args)));
      (function(_this) {
        return (function(__iced_k) {
          __iced_deferrals = new iced.Deferrals(__iced_k, {
            parent: ___iced_passed_deferral,
            filename: "/home/jacko/node-client/src/sigs.iced",
            funcname: "BaseSigGen._store_signature"
          });
          req.post({
            need_cookie: true,
            endpoint: endpoint,
            args: args
          }, __iced_deferrals.defer({
            assign_fn: (function() {
              return function() {
                err = arguments[0];
                return body = arguments[1];
              };
            })(),
            lineno: 97
          }));
          __iced_deferrals._fulfill();
        });
      })(this)((function(_this) {
        return function() {
          if (typeof err === "undefined" || err === null) {
            _this.proof_text = body.proof_text, _this.proof_id = body.proof_id, _this.sig_id = body.sig_id, _this.proof_metadata = body.proof_metadata;
            log.debug("| reply with value: " + (JSON.stringify(body)));
          }
          (function(__iced_k) {
            if (!(typeof err !== "undefined" && err !== null) && _this.expect_proof_text()) {
              (function(__iced_k) {
                if (_this.proof_text == null) {
                  return __iced_k(err = new Error("Server didn't reply with proof text"));
                } else {
                  (function(__iced_k) {
                    __iced_deferrals = new iced.Deferrals(__iced_k, {
                      parent: ___iced_passed_deferral,
                      filename: "/home/jacko/node-client/src/sigs.iced",
                      funcname: "BaseSigGen._store_signature"
                    });
                    _this.eng.sanity_check_proof_text({
                      args: args,
                      proof_text: _this.proof_text
                    }, __iced_deferrals.defer({
                      assign_fn: (function() {
                        return function() {
                          return err = arguments[0];
                        };
                      })(),
                      lineno: 107
                    }));
                    __iced_deferrals._fulfill();
                  })(function() {
                    return __iced_k(err != null ? log.warn("Server replied with a suspect proof text") : void 0);
                  });
                }
              })(__iced_k);
            } else {
              return __iced_k();
            }
          })(function() {
            log.debug("- stored signature (err = " + (typeof err !== "undefined" && err !== null ? err.message : void 0) + ")");
            return cb(err);
          });
        };
      })(this));
    };

    BaseSigGen.prototype.run = function(cb) {
      var esc, ___iced_passed_deferral, __iced_deferrals, __iced_k;
      __iced_k = __iced_k_noop;
      ___iced_passed_deferral = iced.findDeferral(arguments);
      esc = make_esc(cb, "BaseSigGen::run");
      (function(_this) {
        return (function(__iced_k) {
          __iced_deferrals = new iced.Deferrals(__iced_k, {
            parent: ___iced_passed_deferral,
            filename: "/home/jacko/node-client/src/sigs.iced",
            funcname: "BaseSigGen.run"
          });
          _this._get_announce_number(esc(__iced_deferrals.defer({
            lineno: 118
          })));
          __iced_deferrals._fulfill();
        });
      })(this)((function(_this) {
        return function() {
          (function(__iced_k) {
            __iced_deferrals = new iced.Deferrals(__iced_k, {
              parent: ___iced_passed_deferral,
              filename: "/home/jacko/node-client/src/sigs.iced",
              funcname: "BaseSigGen.run"
            });
            _this._do_signature(esc(__iced_deferrals.defer({
              lineno: 119
            })));
            __iced_deferrals._fulfill();
          })(function() {
            (function(__iced_k) {
              __iced_deferrals = new iced.Deferrals(__iced_k, {
                parent: ___iced_passed_deferral,
                filename: "/home/jacko/node-client/src/sigs.iced",
                funcname: "BaseSigGen.run"
              });
              _this._store_signature(esc(__iced_deferrals.defer({
                lineno: 120
              })));
              __iced_deferrals._fulfill();
            })(function() {
              return cb(null, _this.sig);
            });
          });
        };
      })(this));
    };

    BaseSigGen.prototype.normalize_name = function(n, cb) {
      var klass, ret;
      klass = this._binding_klass();
      ret = klass.normalize_name(n);
      return cb(null, ret);
    };

    BaseSigGen.prototype.show_proof_text = function() {
      return this.proof_text;
    };

    BaseSigGen.prototype.check_name = function(s) {
      return this._binding_klass().check_name(s);
    };

    BaseSigGen.prototype.check_name_input = function(s) {
      return this.check_name(s);
    };

    BaseSigGen.prototype.single_occupancy = function() {
      return this._binding_klass().single_occupancy();
    };

    BaseSigGen.prototype.get_warnings = function(_arg) {
      _arg;
      return [];
    };

    BaseSigGen.prototype.do_recheck = function(i) {
      return true;
    };

    BaseSigGen.prototype.do_precheck = function(_arg, cb) {
      var remote_name_normalized;
      remote_name_normalized = _arg.remote_name_normalized;
      return cb(null);
    };

    BaseSigGen.prototype.make_retry_msg = function(code) {
      return "Didn't find the posted proof.";
    };

    return BaseSigGen;

  })();

  exports.KeybaseProofGen = KeybaseProofGen = (function(_super) {
    __extends(KeybaseProofGen, _super);

    function KeybaseProofGen() {
      return KeybaseProofGen.__super__.constructor.apply(this, arguments);
    }

    KeybaseProofGen.prototype._v_modify_store_arg = function(arg) {
      arg.type = "web_service_binding.keybase";
      return arg.is_remote_proof = false;
    };

    KeybaseProofGen.prototype._make_binding_eng = function(arg) {
      return new proofs.KeybaseBinding(arg);
    };

    return KeybaseProofGen;

  })(BaseSigGen);

  exports.KeybasePushProofGen = KeybasePushProofGen = (function(_super) {
    __extends(KeybasePushProofGen, _super);

    function KeybasePushProofGen() {
      return KeybasePushProofGen.__super__.constructor.apply(this, arguments);
    }

    KeybasePushProofGen.prototype._store_signature = function(cb) {
      return cb(null);
    };

    KeybasePushProofGen.prototype._make_binding_eng = function(arg) {
      return new proofs.KeybaseBinding(arg);
    };

    return KeybasePushProofGen;

  })(BaseSigGen);

  exports.CryptocurrencySigGen = CryptocurrencySigGen = (function(_super) {
    __extends(CryptocurrencySigGen, _super);

    function CryptocurrencySigGen(args) {
      this.cryptocurrency = args.cryptocurrency;
      CryptocurrencySigGen.__super__.constructor.call(this, args);
    }

    CryptocurrencySigGen.prototype._make_binding_eng = function(arg) {
      arg.cryptocurrency = this.cryptocurrency;
      return new proofs.Cryptocurrency(arg);
    };

    CryptocurrencySigGen.prototype._v_modify_store_arg = function(arg) {
      arg.type = "cryptocurrency";
      return arg.is_remote_proof = false;
    };

    return CryptocurrencySigGen;

  })(BaseSigGen);

  exports.AnnouncementSigGen = AnnouncementSigGen = (function(_super) {
    __extends(AnnouncementSigGen, _super);

    function AnnouncementSigGen(args) {
      this.announcement = args.announcement;
      AnnouncementSigGen.__super__.constructor.call(this, args);
    }

    AnnouncementSigGen.prototype._make_binding_eng = function(arg) {
      arg.announcement = this.announcement;
      return new proofs.Announcement(arg);
    };

    AnnouncementSigGen.prototype._v_modify_store_arg = function(arg) {
      arg.type = "announcement";
      return arg.is_remote_proof = false;
    };

    return AnnouncementSigGen;

  })(BaseSigGen);

  exports.TrackerProofGen = TrackerProofGen = (function(_super) {
    __extends(TrackerProofGen, _super);

    function TrackerProofGen(args) {
      this.prev = args.prev, this.seqno = args.seqno, this.uid = args.uid, this.track = args.track;
      TrackerProofGen.__super__.constructor.call(this, args);
    }

    TrackerProofGen.prototype._get_announce_number = function(cb) {
      return cb(null);
    };

    TrackerProofGen.prototype._make_binding_eng = function(arg) {
      arg.track = this.track;
      return new proofs.Track(arg);
    };

    TrackerProofGen.prototype._v_modify_store_arg = function(arg) {
      arg.uid = this.uid;
      return arg.type = "track";
    };

    TrackerProofGen.prototype._get_api_endpoint = function() {
      return "follow";
    };

    return TrackerProofGen;

  })(BaseSigGen);

  exports.UntrackerProofGen = UntrackerProofGen = (function(_super) {
    __extends(UntrackerProofGen, _super);

    function UntrackerProofGen(args) {
      this.uid = args.uid, this.untrack = args.untrack, this.seqno = args.seqno, this.prev = args.prev;
      UntrackerProofGen.__super__.constructor.call(this, args);
    }

    UntrackerProofGen.prototype._get_announce_number = function(cb) {
      return cb(null);
    };

    UntrackerProofGen.prototype._make_binding_eng = function(arg) {
      arg.untrack = this.untrack;
      return new proofs.Untrack(arg);
    };

    UntrackerProofGen.prototype._v_modify_store_arg = function(arg) {
      arg.uid = this.uid;
      return arg.type = "untrack";
    };

    UntrackerProofGen.prototype._get_api_endpoint = function() {
      return "follow";
    };

    return UntrackerProofGen;

  })(BaseSigGen);

  strip_at = function(x) {
    if ((x != null) && x.length && x[0] === '@') {
      return x.slice(1);
    } else {
      return x;
    }
  };

  SocialNetworkProofGen = (function(_super) {
    __extends(SocialNetworkProofGen, _super);

    function SocialNetworkProofGen(args) {
      this.remote_username = args.remote_name_normalized;
      SocialNetworkProofGen.__super__.constructor.call(this, args);
    }

    SocialNetworkProofGen.prototype._make_binding_eng = function(args) {
      var klass;
      args.user.remote = this.remote_username;
      klass = this._binding_klass();
      return new klass(args);
    };

    SocialNetworkProofGen.prototype._v_modify_store_arg = function(arg) {
      arg.remote_username = this.remote_username;
      return arg.type = "web_service_binding." + this._remote_service_name();
    };

    SocialNetworkProofGen.prototype.get_prompt = function() {
      return "Your username on " + (this.display_name());
    };

    SocialNetworkProofGen.prototype.prompter = function() {
      var klass, ret;
      klass = this._binding_klass();
      ret = {
        prompt: this.get_prompt(),
        checker: {
          f: klass.check_name,
          hint: klass.name_hint(),
          normalize: klass.normalize_name
        }
      };
      return ret;
    };

    SocialNetworkProofGen.prototype.expect_proof_text = function() {
      return true;
    };

    return SocialNetworkProofGen;

  })(BaseSigGen);

  exports.RevokeProofSigGen = RevokeProofSigGen = (function(_super) {
    __extends(RevokeProofSigGen, _super);

    function RevokeProofSigGen(args) {
      this.revoke_sig_id = args.sig_id;
      RevokeProofSigGen.__super__.constructor.call(this, args);
    }

    RevokeProofSigGen.prototype._make_binding_eng = function(args) {
      args.revoke = {
        sig_id: this.revoke_sig_id
      };
      return new proofs.Revoke(args);
    };

    RevokeProofSigGen.prototype._v_modify_store_arg = function(arg) {
      return arg.revoke_sig_id = this.revoke_sig_id;
    };

    RevokeProofSigGen.prototype._get_api_endpoint = function() {
      return "sig/revoke";
    };

    return RevokeProofSigGen;

  })(BaseSigGen);

  exports.DnsProofGen = DnsProofGen = (function(_super) {
    __extends(DnsProofGen, _super);

    DnsProofGen.prototype._binding_klass = function() {
      return proofs.DnsBinding;
    };

    function DnsProofGen(args) {
      this.remote_host = args.remote_name_normalized;
      DnsProofGen.__super__.constructor.call(this, args);
    }

    DnsProofGen.prototype._make_binding_eng = function(args) {
      var klass;
      args.remote_host = this.remote_host;
      klass = this._binding_klass();
      return new klass(args);
    };

    DnsProofGen.prototype._v_modify_store_arg = function(arg) {
      arg.remote_host = this.remote_host;
      return arg.type = "web_service_binding.dns";
    };

    DnsProofGen.prototype.instructions = function() {
      var h, hosts, search;
      search = [this.remote_host, ["_keybase", this.remote_host].join(".")];
      hosts = ((function() {
        var _i, _len, _results;
        _results = [];
        for (_i = 0, _len = search.length; _i < _len; _i++) {
          h = search[_i];
          _results.push(colors.bold(h));
        }
        return _results;
      })()).join(" OR ");
      return "Please save the following as a DNS TXT entry for " + hosts;
    };

    DnsProofGen.prototype.display_name = function() {
      return this.remote_host;
    };

    DnsProofGen.prototype.prompter = function() {
      var klass;
      klass = this._binding_klass();
      return {
        prompt: "DNS Domain to check",
        checker: {
          f: (function(_this) {
            return function(i) {
              return _this.check_name_input(i);
            };
          })(this),
          hint: klass.name_hint()
        }
      };
    };

    DnsProofGen.prototype.check_name_input = function(i) {
      return this._binding_klass().check_name(i);
    };

    DnsProofGen.prototype.normalize_name = function(i, cb) {
      var err, u;
      u = this._binding_klass().parse(i);
      if (u == null) {
        err = new E.ArgsError("Failed to parse " + i + " as a DNS domain");
      }
      return cb(err, u);
    };

    DnsProofGen.prototype.do_recheck = function(i) {
      log.info("We couldn't find a DNS proof for " + this.remote_host + "....." + (colors.bold('yet')));
      log.info("DNS propagation can be slow; we'll keep trying and email you the result.");
      return false;
    };

    return DnsProofGen;

  })(BaseSigGen);

  exports.GenericWebSiteProofGen = GenericWebSiteProofGen = (function(_super) {
    __extends(GenericWebSiteProofGen, _super);

    GenericWebSiteProofGen.prototype._binding_klass = function() {
      return proofs.GenericWebSiteBinding;
    };

    function GenericWebSiteProofGen(args) {
      this.remote_host = args.remote_name_normalized;
      GenericWebSiteProofGen.__super__.constructor.call(this, args);
    }

    GenericWebSiteProofGen.prototype._make_binding_eng = function(args) {
      var klass;
      args.remote_host = this.remote_host;
      klass = this._binding_klass();
      return new klass(args);
    };

    GenericWebSiteProofGen.prototype._v_modify_store_arg = function(arg) {
      arg.remote_host = this.remote_host;
      return arg.type = "web_service_binding.generic";
    };

    GenericWebSiteProofGen.prototype.styled_filenames = function(h) {
      var f, files;
      files = this.filenames(h);
      return ((function() {
        var _i, _len, _results;
        _results = [];
        for (_i = 0, _len = files.length; _i < _len; _i++) {
          f = files[_i];
          _results.push(colors.bold(f));
        }
        return _results;
      })()).join("\n  or ");
    };

    GenericWebSiteProofGen.prototype.instructions = function() {
      return "Please save the following file as " + (this.styled_filenames());
    };

    GenericWebSiteProofGen.prototype.display_name = function() {
      return this.filenames().join(' OR ');
    };

    GenericWebSiteProofGen.prototype.filenames = function(h) {
      var f, files, _i, _len, _results;
      files = proofs.GenericWebSiteScraper.FILES;
      _results = [];
      for (_i = 0, _len = files.length; _i < _len; _i++) {
        f = files[_i];
        _results.push((h || this.remote_host) + "/" + f);
      }
      return _results;
    };

    GenericWebSiteProofGen.prototype.prompter = function() {
      var klass;
      klass = this._binding_klass();
      return {
        prompt: "Hostname to check",
        checker: {
          f: (function(_this) {
            return function(i) {
              return _this.check_name_input(i);
            };
          })(this),
          hint: klass.name_hint()
        }
      };
    };

    GenericWebSiteProofGen.prototype.rewrite_hostname = function(i) {
      if (!i.match(/^https?:\/\//)) {
        i = "https://" + i;
      }
      return i;
    };

    GenericWebSiteProofGen.prototype.check_name_input = function(i) {
      return this._binding_klass().check_name(this.rewrite_hostname(i));
    };

    GenericWebSiteProofGen.prototype.get_warnings = function(_arg) {
      var remote_name_normalized;
      remote_name_normalized = _arg.remote_name_normalized;
      return ["You'll be asked to post a file available at", "     " + this.styled_filenames(remote_name_normalized)];
    };

    GenericWebSiteProofGen.prototype.normalize_name = function(i, cb) {
      var args, err, hostname, n, protocol, res, ret, u, ___iced_passed_deferral, __iced_deferrals, __iced_k;
      __iced_k = __iced_k_noop;
      ___iced_passed_deferral = iced.findDeferral(arguments);
      n = this.rewrite_hostname(i);
      u = this._binding_klass().parse(n);
      ret = null;
      (function(_this) {
        return (function(__iced_k) {
          if (u == null) {
            return __iced_k(err = new E.ArgsError("Failed to parse " + i + " is a valid internet host"));
          } else {
            hostname = u.hostname;
            args = {
              endpoint: "remotes/check",
              args: {
                hostname: hostname
              }
            };
            (function(__iced_k) {
              __iced_deferrals = new iced.Deferrals(__iced_k, {
                parent: ___iced_passed_deferral,
                filename: "/home/jacko/node-client/src/sigs.iced",
                funcname: "GenericWebSiteProofGen.normalize_name"
              });
              req.get(args, __iced_deferrals.defer({
                assign_fn: (function() {
                  return function() {
                    err = arguments[0];
                    return res = arguments[1];
                  };
                })(),
                lineno: 414
              }));
              __iced_deferrals._fulfill();
            })(function() {
              var _ref;
              return __iced_k(err != null ? void 0 : (protocol = typeof res !== "undefined" && res !== null ? (_ref = res.results) != null ? _ref.first : void 0 : void 0) == null ? err = new E.HostError("Host " + n + " is down; tried 'http' and 'https' protocols") : i.match(/^https:\/\//) && (protocol !== 'https:') ? err = new E.SecurityError("You specified HTTPS for " + i + " but only HTTP is available") : ret = urlmod.format({
                protocol: protocol,
                hostname: hostname
              }));
            });
          }
        });
      })(this)((function(_this) {
        return function() {
          return cb(err, ret);
        };
      })(this));
    };

    GenericWebSiteProofGen.prototype.expect_proof_text = function() {
      return true;
    };

    return GenericWebSiteProofGen;

  })(BaseSigGen);

  exports.TwitterProofGen = TwitterProofGen = (function(_super) {
    __extends(TwitterProofGen, _super);

    function TwitterProofGen() {
      return TwitterProofGen.__super__.constructor.apply(this, arguments);
    }

    TwitterProofGen.prototype._binding_klass = function() {
      return proofs.TwitterBinding;
    };

    TwitterProofGen.prototype._remote_service_name = function() {
      return "twitter";
    };

    TwitterProofGen.prototype.imperative_verb = function() {
      return "tweet";
    };

    TwitterProofGen.prototype.display_name = function() {
      return "Twitter";
    };

    TwitterProofGen.prototype.instructions = function() {
      return "Please " + (colors.bold('publicly')) + " tweet the following:";
    };

    TwitterProofGen.prototype.make_retry_msg = function(status) {
      switch (status) {
        case proofs.constants.v_codes.PERMISSION_DENIED:
          return "Permission denied! We can't support private feeds.";
        default:
          return TwitterProofGen.__super__.make_retry_msg.call(this);
      }
    };

    return TwitterProofGen;

  })(SocialNetworkProofGen);

  exports.RedditProofGen = RedditProofGen = (function(_super) {
    __extends(RedditProofGen, _super);

    function RedditProofGen() {
      return RedditProofGen.__super__.constructor.apply(this, arguments);
    }

    RedditProofGen.prototype._binding_klass = function() {
      return proofs.RedditBinding;
    };

    RedditProofGen.prototype._remote_service_name = function() {
      return "reddit";
    };

    RedditProofGen.prototype.imperative_verb = function() {
      return "post";
    };

    RedditProofGen.prototype.display_name = function() {
      return "Reddit";
    };

    RedditProofGen.prototype.instructions = function() {
      return "Please click on the following link to post to Reddit:";
    };

    RedditProofGen.prototype.show_proof_text = function() {
      var body, title;
      body = this.proof_text;
      title = this.proof_metadata.title;
      return url_reencode(urlmod.format({
        protocol: "https",
        host: "www.reddit.com",
        pathname: "/r/KeybaseProofs/submit",
        query: {
          title: this.proof_metadata.title,
          text: this.proof_text
        }
      }));
    };

    return RedditProofGen;

  })(SocialNetworkProofGen);

  exports.GithubProofGen = GithubProofGen = (function(_super) {
    __extends(GithubProofGen, _super);

    function GithubProofGen() {
      return GithubProofGen.__super__.constructor.apply(this, arguments);
    }

    GithubProofGen.prototype._binding_klass = function() {
      return proofs.GithubBinding;
    };

    GithubProofGen.prototype._remote_service_name = function() {
      return "github";
    };

    GithubProofGen.prototype.imperative_verb = function() {
      return "post a Gist with";
    };

    GithubProofGen.prototype.display_name = function() {
      return "GitHub";
    };

    GithubProofGen.prototype.instructions = function() {
      return "Please " + (colors.bold('publicly')) + " post the following Gist, and name it " + (colors.bold(colors.red('keybase.md'))) + ":";
    };

    GithubProofGen.prototype.make_retry_msg = function(status) {
      switch (status) {
        case proofs.constants.v_codes.PERMISSION_DENIED:
          return "Permission denied! Make sure your Gist is public";
        default:
          return GithubProofGen.__super__.make_retry_msg.call(this);
      }
    };

    return GithubProofGen;

  })(SocialNetworkProofGen);

  exports.HackerNewsProofGen = HackerNewsProofGen = (function(_super) {
    __extends(HackerNewsProofGen, _super);

    function HackerNewsProofGen() {
      return HackerNewsProofGen.__super__.constructor.apply(this, arguments);
    }

    HackerNewsProofGen.prototype._binding_klass = function() {
      return proofs.HackerNewsBinding;
    };

    HackerNewsProofGen.prototype._remote_service_name = function() {
      return "hackernews";
    };

    HackerNewsProofGen.prototype.imperative_verb = function() {
      return "update your profile with";
    };

    HackerNewsProofGen.prototype.display_name = function() {
      return "HackerNews";
    };

    HackerNewsProofGen.prototype.instructions = function() {
      return "Please edit your HackerNews profile to contain the following text. Click here: https://news.ycombinator.com/user?id=" + this.remote_username;
    };

    HackerNewsProofGen.prototype.do_recheck = function(i) {
      log.info("We couldn't find a posted proof for " + this.remote_username + "....." + (colors.bold('yet')));
      if (i < 3) {
        log.info("HackerNews's API is slow to update, so be patient...try again?");
        return true;
      } else {
        log.info("We'll keep trying and let you know!");
        return false;
      }
    };

    HackerNewsProofGen.prototype.get_warnings = function(_arg) {
      var remote_name_normalized;
      remote_name_normalized = _arg.remote_name_normalized;
      return [];
    };

    HackerNewsProofGen.prototype.do_precheck = function(_arg, cb) {
      var err, json, remote_name_normalized, scraper, ___iced_passed_deferral, __iced_deferrals, __iced_k;
      __iced_k = __iced_k_noop;
      ___iced_passed_deferral = iced.findDeferral(arguments);
      remote_name_normalized = _arg.remote_name_normalized;
      scraper = (new scrapers.HackerNews).make_scraper();
      (function(_this) {
        return (function(__iced_k) {
          __iced_deferrals = new iced.Deferrals(__iced_k, {
            parent: ___iced_passed_deferral,
            filename: "/home/jacko/node-client/src/sigs.iced",
            funcname: "HackerNewsProofGen.do_precheck"
          });
          scraper.get_karma(remote_name_normalized, __iced_deferrals.defer({
            assign_fn: (function() {
              return function() {
                err = arguments[0];
                return json = arguments[1];
              };
            })(),
            lineno: 504
          }));
          __iced_deferrals._fulfill();
        });
      })(this)((function(_this) {
        return function() {
          if (typeof err !== "undefined" && err !== null) {

          } else if (!(typeof json !== "undefined" && json !== null)) {
            log.warn("" + (colors.bold("ATTENTION")) + ": HackerNews only publishes users to their API with " + (colors.bold("karma > 1")) + ".");
            log.warn("Your account " + (colors.bold(remote_name_normalized)) + " doesn't qualify, or doesn't exist!");
            err = new E.KarmaError("Insufficient HackerNews karma (>= 2 needed) or bad username (case sensitive!)");
          }
          return cb(err);
        };
      })(this));
    };

    HackerNewsProofGen.prototype.get_prompt = function() {
      return "Your username on " + (this.display_name()) + " (**case sensitive**)";
    };

    return HackerNewsProofGen;

  })(SocialNetworkProofGen);

  exports.CoinbaseProofGen = CoinbaseProofGen = (function(_super) {
    __extends(CoinbaseProofGen, _super);

    function CoinbaseProofGen() {
      return CoinbaseProofGen.__super__.constructor.apply(this, arguments);
    }

    CoinbaseProofGen.prototype._binding_klass = function() {
      return proofs.CoinbaseBinding;
    };

    CoinbaseProofGen.prototype._remote_service_name = function() {
      return "coinbase";
    };

    CoinbaseProofGen.prototype.imperative_verb = function() {
      return "update your Coinbase profile with";
    };

    CoinbaseProofGen.prototype.display_name = function() {
      return "coinbase";
    };

    CoinbaseProofGen.prototype.instructions = function() {
      return "Please update your Coinbase profile to show this proof. Click here: https://coinbase.com/" + this.remote_username + "/public-key";
    };

    return CoinbaseProofGen;

  })(SocialNetworkProofGen);

  exports.SignatureEngine = SignatureEngine = (function() {
    function SignatureEngine(_arg) {
      this.km = _arg.km;
    }

    SignatureEngine.prototype.get_km = function() {
      return this.km;
    };

    SignatureEngine.prototype.box = function(msg, cb) {
      var arg, err, out, pgp, ___iced_passed_deferral, __iced_deferrals, __iced_k;
      __iced_k = __iced_k_noop;
      ___iced_passed_deferral = iced.findDeferral(arguments);
      out = {};
      arg = {
        stdin: new Buffer(msg, 'utf8'),
        args: ["-u", this.km.get_pgp_key_id(), "--sign", "-a", "--keyid-format", "long"],
        quiet: true
      };
      (function(_this) {
        return (function(__iced_k) {
          __iced_deferrals = new iced.Deferrals(__iced_k, {
            parent: ___iced_passed_deferral,
            filename: "/home/jacko/node-client/src/sigs.iced",
            funcname: "SignatureEngine.box"
          });
          master_ring().gpg(arg, __iced_deferrals.defer({
            assign_fn: (function() {
              return function() {
                err = arguments[0];
                return pgp = arguments[1];
              };
            })(),
            lineno: 544
          }));
          __iced_deferrals._fulfill();
        });
      })(this)((function(_this) {
        return function() {
          var _ref;
          if (typeof err === "undefined" || err === null) {
            out.pgp = pgp = pgp.toString('utf8');
            _ref = decode(pgp), err = _ref[0], msg = _ref[1];
            if (err == null) {
              out.raw = msg.body;
            }
          }
          return cb(err, out);
        };
      })(this));
    };

    return SignatureEngine;

  })();

}).call(this);


text:
<?php
namespace Luracast\Restler\Format;

use Luracast\Restler\Data\Object;
use Luracast\Restler\RestException;

class JsonFormat extends Format
{
    /**
     * @var boolean|null  shim for json_encode option JSON_PRETTY_PRINT set
     * it to null to use smart defaults
     */
    public static $prettyPrint = null;

    /**
     * @var boolean|null  shim for json_encode option JSON_UNESCAPED_SLASHES
     * set it to null to use smart defaults
     */
    public static $unEscapedSlashes = null;

    /**
     * @var boolean|null  shim for json_encode JSON_UNESCAPED_UNICODE set it
     * to null to use smart defaults
     */
    public static $unEscapedUnicode = null;

    /**
     * @var boolean|null  shim for json_decode JSON_BIGINT_AS_STRING set it to
     * null to
     * use smart defaults
     */
    public static $bigIntAsString = null;

    const MIME = 'application/json';
    const EXTENSION = 'json';

    public function encode($data, $humanReadable = false)
    {
        if (!is_null(self::$prettyPrint)) {
            $humanReadable = self::$prettyPrint;
        }
        if (is_null(self::$unEscapedSlashes)) {
            self::$unEscapedSlashes = $humanReadable;
        }
        if (is_null(self::$unEscapedUnicode)) {
            self::$unEscapedUnicode = $this->charset == 'utf-8';
        }
        $options = 0;
        if ((PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 4) // PHP >= 5.4
            || PHP_MAJOR_VERSION > 5 // PHP >= 6.0
        ) {
            if ($humanReadable) $options |= JSON_PRETTY_PRINT;
            if (self::$unEscapedSlashes) $options |= JSON_UNESCAPED_SLASHES;
            if (self::$bigIntAsString) $options |= JSON_BIGINT_AS_STRING;
            if (self::$unEscapedUnicode) $options |= JSON_UNESCAPED_UNICODE;
            return json_encode(
                Object::toArray($data, true), $options
            );
        }

        $result = json_encode(Object::toArray($data, true));
        if ($humanReadable) $result = $this->formatJson($result);
        if (self::$unEscapedUnicode) {
            $result = preg_replace_callback('/\\\u(\w\w\w\w)/',
                function($matches)
                {
                    if (function_exists('mb_convert_encoding'))
                	{
                		return mb_convert_encoding(pack('H*', $matches[1]), 'UTF-8', 'UTF-16BE');
                	}
                	else
                	{
                		return iconv('UTF-16BE','UTF-8',pack('H*', $matches[1]));
                	}
                }
                , $result);
        }
        if (self::$unEscapedSlashes) $result = str_replace('\/', '/', $result);
        return $result;
    }

    public function decode($data)
    {
        $options = 0;
        if (self::$bigIntAsString) {
            if ((PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 4) // PHP >= 5.4
                || PHP_MAJOR_VERSION > 5 // PHP >= 6.0
            ) {
                $options |= JSON_BIGINT_AS_STRING;
            } else {
                $data = preg_replace(
                    '/:\s*(\-?\d+(\.\d+)?([e|E][\-|\+]\d+)?)/',
                    ': "$1"', $data
                );
            }
        }
        $decoded = json_decode($data, $options);
        if (function_exists('json_last_error')) {
            switch (json_last_error()) {
                case JSON_ERROR_NONE :
                    return Object::toArray($decoded);
                    break;
                case JSON_ERROR_DEPTH :
                    $message = 'maximum stack depth exceeded';
                    break;
                case JSON_ERROR_STATE_MISMATCH :
                    $message = 'underflow or the modes mismatch';
                    break;
                case JSON_ERROR_CTRL_CHAR :
                    $message = 'unexpected control character found';
                    break;
                case JSON_ERROR_SYNTAX :
                    $message = 'malformed JSON';
                    break;
                case JSON_ERROR_UTF8 :
                    $message = 'malformed UTF-8 characters, possibly ' .
                        'incorrectly encoded';
                    break;
                default :
                    $message = 'unknown error';
                    break;
            }
            throw new RestException (400, 'Error parsing JSON, ' . $message);
        } elseif (strlen($data) && $decoded === null || $decoded === $data) {
            throw new RestException (400, 'Error parsing JSON');
        }

        return Object::toArray($decoded);
    }

    /**
     * Pretty print JSON string
     *
     * @param  string $json
     *
     * @return string formatted json
     */
    private function formatJson($json)
    {
        $tab = '  ';
        $newJson = '';
        $indentLevel = 0;
        $inString = false;
        $len = strlen($json);
        for ($c = 0; $c < $len; $c++) {
            $char = $json [$c];
            switch ($char) {
                case '{' :
                case '[' :
                    if (!$inString) {
                        $newJson .= $char . "\n" .
                            str_repeat($tab, $indentLevel + 1);
                        $indentLevel++;
                    } else {
                        $newJson .= $char;
                    }
                    break;
                case '}' :
                case ']' :
                    if (!$inString) {
                        $indentLevel--;
                        $newJson .= "\n" .
                            str_repeat($tab, $indentLevel) . $char;
                    } else {
                        $newJson .= $char;
                    }
                    break;
                case ',' :
                    if (!$inString) {
                        $newJson .= ",\n" .
                            str_repeat($tab, $indentLevel);
                    } else {
                        $newJson .= $char;
                    }
                    break;
                case ':' :
                    if (!$inString) {
                        $newJson .= ': ';
                    } else {
                        $newJson .= $char;
                    }
                    break;
                case '"' :
                    if ($c == 0) {
                        $inString = true;
                    } elseif ($c > 0 && $json [$c - 1] != '\\') {
                        $inString = !$inString;
                    }
                default :
                    $newJson .= $char;
                    break;
            }
        }

        return $newJson;
    }
}


text:
<?php

namespace Google\Service\CloudIAP;

class CorsSettings extends \Google\Model
{
  /**
   * @var bool
   */
  public $allowHttpOptions;

  /**
   * @param bool
   */
  public function setAllowHttpOptions($allowHttpOptions)
  {
    $this->allowHttpOptions = $allowHttpOptions;
  }
  /**
   * @return bool
   */
  public function getAllowHttpOptions()
  {
    return $this->allowHttpOptions;
  }
}

// Adding a class alias for backwards compatibility with the previous class name.
class_alias(CorsSettings::class, 'Google_Service_CloudIAP_CorsSettings');