text:
<?xml version="1.0" encoding="UTF-8"?>
<!--
  ~ Copyright 2016 Red Hat, Inc. and/or its affiliates
  ~ and other contributors as indicated by the @author tags.
  ~
  ~ 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.
  -->
<module xmlns="urn:jboss:module:1.3" name="org.eclipse.sisu" slot="main">
    <properties>
        <property name="jboss.api" value="private"/>
    </properties>
    <resources>
        <artifact name="${org.eclipse.sisu:org.eclipse.sisu.inject}"/>
        <artifact name="${org.eclipse.sisu:org.eclipse.sisu.plexus}"/>
    </resources>
    <dependencies>
        <module name="javax.api"/>
        <module name="javax.enterprise.api"/>
        <module name="javax.inject.api"/>
        <module name="org.codehouse.plexus"/>
        <module name="org.sonatype.sisu"/>
    </dependencies>
</module>


text:
/**
 * This file is automatically generated by wheat-build.
 * Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 */

package x7c1.linen.glue.res.layout;

import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.support.design.widget.TextInputLayout;
import android.support.v7.widget.AppCompatEditText;

public class SourceSearchStart extends RecyclerView.ViewHolder {

    public final android.support.design.widget.TextInputLayout originUrlLayout;
    public final android.support.v7.widget.AppCompatEditText originUrl;

    public SourceSearchStart(
        View itemView,
        android.support.design.widget.TextInputLayout originUrlLayout,
        android.support.v7.widget.AppCompatEditText originUrl
    ){
        super(itemView);
        this.originUrlLayout = originUrlLayout;
        this.originUrl = originUrl;
    }
}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <title>OpenLayers: Sketch handlers crossing the dateline</title>
    <link rel="stylesheet" href="../../theme/default/style.css" type="text/css">
    <link rel="stylesheet" href="../../examples/style.css" type="text/css">

OpenLayers sketch handlers crossing the dateline example

        international date line, dateline, sketch

        Start digitizing a polygon or line
        on one side of the international dateline, and then cross the dateline
        whilst digitizing. The feature should behave like digitizing on any
        other location.


text:
title: Introduction to the React Challenges
block: React
superBlock: Front End Development Libraries
---

## Introduction to the React Challenges

[React](https://reactjs.org/), created by Facebook, is an open-source JavaScript library for building user interfaces. It is used to create components, handle state and props, utilize event listeners and certain life cycle methods to update data as it changes.

React combines HTML with JavaScript functionality to create its own markup language, JSX. This section will introduce you to all of these concepts and how to implement them for use with your own projects.


text:
"""Tests for mysql_service_benchmark."""
import logging
import os
import unittest

from perfkitbenchmarker import sample
from perfkitbenchmarker import test_util
from perfkitbenchmarker.benchmarks import mysql_service_benchmark

class MySQLServiceBenchmarkTestCase(unittest.TestCase,
                                    test_util.SamplesTestMixin):

  def setUp(self):
    path = os.path.join(os.path.dirname(__file__), '..', 'data',
                        'sysbench-output-sample.txt')
    with open(path) as fp:
      self.contents = fp.read()

  def testParseSysbenchResult(self):
    results = []
    metadata = {}
    mysql_service_benchmark.ParseSysbenchOutput(
        self.contents, results, metadata)
    logging.info('results are, %s', results)
    expected_results = [
        sample.Sample('sysbench tps p1', 526.38, 'NA', {}),
        sample.Sample('sysbench tps p5', 526.38, 'NA', {}),
        sample.Sample('sysbench tps p50', 579.5, 'NA', {}),
        sample.Sample('sysbench tps p90', 636.0, 'NA', {}),
        sample.Sample('sysbench tps p99', 636.0, 'NA', {}),
        sample.Sample('sysbench tps p99.9', 636.0, 'NA', {}),
        sample.Sample('sysbench tps average', 583.61, 'NA', {}),
        sample.Sample('sysbench tps stddev', 33.639045340624214, 'NA', {}),
        sample.Sample('sysbench tps cv', 0.05763959723209714, 'NA', {}),
        sample.Sample('sysbench latency min', 18.31, 'milliseconds', {}),
        sample.Sample('sysbench latency avg', 27.26, 'milliseconds', {}),
        sample.Sample('sysbench latency max', 313.5, 'milliseconds', {}),
        sample.Sample(
            'sysbench latency percentile 99', 57.15,
            'milliseconds', {})]
    self.assertSampleListsEqualUpToTimestamp(results, expected_results)

if __name__ == '__main__':
  unittest.main()


text:
package chav1961.funnypro.core.entities;

import chav1961.funnypro.core.interfaces.IFProEntity;

/**
 *
This class describes real entity

 * @author Alexander Chernomyrdin aka chav1961
 * @since 0.0.1
 */
public class RealEntity implements IFProEntity {
	private long			id;
	private IFProEntity		parent = null;

	/**
	 *
Constructor of the object

	 * @param value real entity value
	 * @param parent parent node
	 */
	public RealEntity(final double value, final IFProEntity parent) {
		this.id = Double.doubleToLongBits(value);
		this.parent = parent;
	}

	/**
	 *
Constructor of the object

	 * @param value real entity value
	 */
	public RealEntity(final double value) {
		this.id = Double.doubleToLongBits(value);
	}

	@Override public EntityType getEntityType() {return EntityType.real;}
	@Override public long getEntityId() {return id;}
	@Override public IFProEntity setEntityId(final long entityId) {this.id = entityId; return this;}
	@Override public IFProEntity getParent() {return parent;}
	@Override public IFProEntity setParent(final IFProEntity entity) {this.parent = entity; return this;}

	@Override public String toString() {return "RealEntity [value=" + Double.longBitsToDouble(id) + "]";}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + (int) (id ^ (id >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj) return true;
		if (obj == null) return false;
		if (getClass() != obj.getClass()) return false;
		RealEntity other = (RealEntity) obj;
		if (id != other.id) return false;
		return true;
	}

	@Override
	public RealEntity clone() throws CloneNotSupportedException {
		return (RealEntity)super.clone();
	}
}


text:
#include "telescope/station/private_station.h"
#include "telescope/station/oskar_station.h"
#include "math/oskar_cmath.h"
#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

void oskar_station_resize(oskar_Station* station, int num_elements,
        int* status)
{
    int feed = 0, dim = 0;
    if (*status || !station) return;
    for (feed = 0; feed < 2; feed++)
    {
        for (dim = 0; dim < 3; dim++)
        {
            oskar_mem_realloc(station->element_true_enu_metres[feed][dim],
                    num_elements, status);
            oskar_mem_realloc(station->element_measured_enu_metres[feed][dim],
                    num_elements, status);
            oskar_mem_realloc(station->element_euler_cpu[feed][dim],
                    num_elements, status);
        }
        oskar_mem_realloc(station->element_weight[feed],
                num_elements, status);
        oskar_mem_realloc(station->element_cable_length_error[feed],
                num_elements, status);
        oskar_mem_realloc(station->element_gain[feed],
                num_elements, status);
        oskar_mem_realloc(station->element_gain_error[feed],
                num_elements, status);
        oskar_mem_realloc(station->element_phase_offset_rad[feed],
                num_elements, status);
        oskar_mem_realloc(station->element_phase_error_rad[feed],
                num_elements, status);
    }
    oskar_mem_realloc(station->element_types, num_elements, status);
    oskar_mem_realloc(station->element_types_cpu, num_elements, status);
    oskar_mem_realloc(station->element_mount_types_cpu, num_elements, status);

    /* Initialise any new elements with default values. */
    if (num_elements > station->num_elements)
    {
        int offset = 0, num_new = 0;
        offset = station->num_elements;
        num_new = num_elements - offset;

        /* Must set default element weight and gain. */
        for (feed = 0; feed < 2; feed++)
        {
            if (station->element_gain[feed])
            {
                oskar_mem_set_value_real(station->element_gain[feed],
                        1.0, offset, num_new, status);
            }
            if (station->element_weight[feed])
            {
                oskar_mem_set_value_real(station->element_weight[feed],
                        1.0, offset, num_new, status);
            }
        }
        memset(oskar_mem_char(station->element_mount_types_cpu) + offset,
                'F', num_new);
    }

    /* Set the new number of elements. */
    station->num_elements = num_elements;
}

#ifdef __cplusplus
}
#endif


text:
/**
 *
 */
package org.spockframework.gentyref;

import java.lang.reflect.Type;
import java.lang.reflect.WildcardType;
import java.util.Arrays;

class WildcardTypeImpl implements WildcardType {
	private final Type[] upperBounds;
	private final Type[] lowerBounds;

	public WildcardTypeImpl(Type[] upperBounds, Type[] lowerBounds) {
		if (upperBounds.length == 0)
			throw new IllegalArgumentException("There must be at least one upper bound. For an unbound wildcard, the upper bound must be Object");
		this.upperBounds = upperBounds;
		this.lowerBounds = lowerBounds;
	}

	public Type[] getUpperBounds() {
		return upperBounds.clone();
	}

	public Type[] getLowerBounds() {
		return lowerBounds.clone();
	}

	@Override
	public boolean equals(Object obj) {
		if (! (obj instanceof WildcardType))
			return false;
		WildcardType other = (WildcardType)obj;
		return Arrays.equals(lowerBounds, other.getLowerBounds())
			&& Arrays.equals(upperBounds, other.getUpperBounds());
	}

	@Override
	public int hashCode() {
		return Arrays.hashCode(lowerBounds) ^ Arrays.hashCode(upperBounds);
	}

	@Override
	public String toString() {
		if (lowerBounds.length > 0) {
			return "? super " + GenericTypeReflector.getTypeName(lowerBounds[0]);
		} else if (upperBounds[0] == Object.class) {
			return "?";
		} else {
			return "? extends " + GenericTypeReflector.getTypeName(upperBounds[0]);
		}
	}
}


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

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Package org.robolectric.annotation (robolectric-parent 3.0 API)</title>
<meta name="date" content="2015-07-08">
<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Uses of Package
org.robolectric.annotation

Packages that use org.robolectric.annotation

Package
Description

org.robolectric

Package containing main Robolectric classes.

org.robolectric.annotation

Package containing Robolectric annotations.

org.robolectric.shadows

Package containing shadow classes for the Android SDK.

org.robolectric.shadows.gms

Shadows for the Google Play Services Library.

org.robolectric.shadows.httpclient

Shadows for Apache HTTP Client.

org.robolectric.shadows.maps

Shadows for Google Maps.

org.robolectric.shadows.multidex

Shadows for the Android Multidex Library.

org.robolectric.shadows.support.v4

Shadows for the Android Support Library.

Classes in org.robolectric.annotation used by org.robolectric

Class and Description

Config

Configuration settings that can be used on a per-class or per-test basis.

Classes in org.robolectric.annotation used by org.robolectric.annotation

Class and Description

AccessibilityChecks.ForRobolectricVersion

Config

Configuration settings that can be used on a per-class or per-test basis.

Classes in org.robolectric.annotation used by org.robolectric.shadows

Class and Description

HiddenApi

Indicates that the annotated method is hidden in the public Android API.

Implementation

Indicates that a method declaration is intended to Shadow a method with the same signature
 on the associated Android class.

Implements

Indicates that a class declaration is intended to Shadow an Android class declaration.

RealObject

Shadow fields annotated @RealObject will have the real instance injected.

Resetter

Indicates that the annotated method is used to reset static state in a shadow.

Classes in org.robolectric.annotation used by org.robolectric.shadows.gms

Class and Description

Implementation

Indicates that a method declaration is intended to Shadow a method with the same signature
 on the associated Android class.

Implements

Indicates that a class declaration is intended to Shadow an Android class declaration.

Classes in org.robolectric.annotation used by org.robolectric.shadows.httpclient

Class and Description

Implementation

Indicates that a method declaration is intended to Shadow a method with the same signature
 on the associated Android class.

Implements

Indicates that a class declaration is intended to Shadow an Android class declaration.

Resetter

Indicates that the annotated method is used to reset static state in a shadow.

Classes in org.robolectric.annotation used by org.robolectric.shadows.maps

Class and Description

HiddenApi

Indicates that the annotated method is hidden in the public Android API.

Implementation

Indicates that a method declaration is intended to Shadow a method with the same signature
 on the associated Android class.

Implements

Indicates that a class declaration is intended to Shadow an Android class declaration.

Classes in org.robolectric.annotation used by org.robolectric.shadows.multidex

Class and Description

Implementation

Indicates that a method declaration is intended to Shadow a method with the same signature
 on the associated Android class.

Implements

Indicates that a class declaration is intended to Shadow an Android class declaration.

Classes in org.robolectric.annotation used by org.robolectric.shadows.support.v4

Class and Description

Implementation

Indicates that a method declaration is intended to Shadow a method with the same signature
 on the associated Android class.

Implements

Indicates that a class declaration is intended to Shadow an Android class declaration.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Copyright © 2015. All rights reserved.


text:
import bind from '../src/index';

describe( '@bind', function() {
  it( 'should bind the context of a given method to the object instance that it is defined on', function() {
    class Test {
      @bind foo() {
        return this;
      }
    }

    var obj = new Test();
    expect( obj.foo() ).to.equal( obj );
    expect( obj.foo.call( undefined ) ).to.equal( obj );
  });
});


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.
-->

<!--
     For more details about configurations options that may appear in
     this file, see http://wiki.apache.org/solr/SolrConfigXml.
-->
<config>
  <luceneMatchVersion>${tests.luceneMatchVersion:LUCENE_CURRENT}</luceneMatchVersion>

  <lib dir="../../contrib/velocity/lib" />
  <lib dir="../../dist/" regex="apache-solr-velocity-\d.*\.jar" />
  <dataDir>${solr.data.dir:}</dataDir>

  <directoryFactory name="DirectoryFactory"
                    class="${solr.directoryFactory:solr.StandardDirectoryFactory}"/>

  <!-- <indexConfig> section could go here, but we want the defaults -->

  <updateHandler class="solr.DirectUpdateHandler2">
  </updateHandler>

  <query>
    <maxBooleanClauses>1024</maxBooleanClauses>
    <filterCache class="solr.FastLRUCache"
                 size="512"
                 initialSize="512"
                 autowarmCount="0"/>
    <queryResultCache class="solr.LRUCache"
                     size="512"
                     initialSize="512"
                     autowarmCount="0"/>
    <documentCache class="solr.LRUCache"
                   size="512"
                   initialSize="512"
                   autowarmCount="0"/>
    <enableLazyFieldLoading>true</enableLazyFieldLoading>

   <queryResultWindowSize>20</queryResultWindowSize>
   <queryResultMaxDocsCached>200</queryResultMaxDocsCached>
    <listener event="newSearcher" class="solr.QuerySenderListener">
      <arr name="queries">
      </arr>
    </listener>
    <listener event="firstSearcher" class="solr.QuerySenderListener">
      <arr name="queries">
        <lst>
          <str name="q">static firstSearcher warming in solrconfig.xml</str>
        </lst>
      </arr>
    </listener>
    <useColdSearcher>false</useColdSearcher>
    <maxWarmingSearchers>2</maxWarmingSearchers>

  </query>
  <requestDispatcher handleSelect="true" >
    <requestParsers enableRemoteStreaming="true"
                    multipartUploadLimitInKB="2048000" />
    <httpCaching never304="true" />
  </requestDispatcher>

  <requestHandler name="search" class="solr.SearchHandler" default="true">
     <lst name="defaults">
       <str name="echoParams">explicit</str>
       <int name="rows">10</int>
     </lst>
    </requestHandler>

  <requestHandler name="/update" class="solr.UpdateRequestHandler"  />

  <!--
     <queryResponseWriter name="xml"
                          default="true"
                          class="solr.XMLResponseWriter" />
     <queryResponseWriter name="json" class="solr.JSONResponseWriter"/>
     <queryResponseWriter name="python" class="solr.PythonResponseWriter"/>
     <queryResponseWriter name="ruby" class="solr.RubyResponseWriter"/>
     <queryResponseWriter name="php" class="solr.PHPResponseWriter"/>
     <queryResponseWriter name="phps" class="solr.PHPSerializedResponseWriter"/>
     <queryResponseWriter name="velocity" class="solr.VelocityResponseWriter"/>
     <queryResponseWriter name="csv" class="solr.CSVResponseWriter"/>
    -->

  <!-- Legacy config for the admin interface -->
  <admin>
    <defaultQuery>*:*</defaultQuery>
  </admin>

</config>


text:
namespace zippylog {
namespace protocol {
namespace response {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

class PongV1;
class FeatureSpecificationV1;
class StreamSegmentStartV1;
class StreamSegmentEndV1;
class SubscriptionAcceptAckV1;
class SubscriptionKeepaliveAckV1;
class SubscriptionStartV1;
class WriteAckV1;
class PluginRegisterAckV1;
class PluginUnregisterAckV1;
class PluginStatusV1;
class Error;

enum ErrorCode {
  ENVELOPE_PARSE_FAILURE = 1,
  INVALID_MESSAGE_NAMESPACE = 2,
  UNKNOWN_REQUEST_TYPE = 3,
  EMPTY_ENVELOPE = 4,
  MISSING_ENUMERATIONS = 5,
  REQUEST_NOT_IMPLEMENTED = 6,
  EMPTY_FIELD = 7,
  FIELD_LENGTHS_DIFFERENT = 8,
  INVALID_STREAM_OFFSET = 9,
  INVALID_OFFSET = 10,
  PATH_NOT_FOUND = 11,
  LIMIT_EXCEEDED = 12,
  UNKNOWN_MESSAGE_FORMAT_VERSION = 13,
  INVALID_PATH = 14,
  UNSUPPORTED_OPERATION_MESSAGE_VERSION = 15,
  EMPTY_MESSAGE = 16,
  PROTOCOL_NO_ENVELOPE = 17,
  GENERAL_ERROR_PROCESSING = 18,
  LUA_ERROR = 19,
  SUBSCRIPTION_REJECTED = 20
};
bool ErrorCode_IsValid(int value);
const ErrorCode ErrorCode_MIN = ENVELOPE_PARSE_FAILURE;
const ErrorCode ErrorCode_MAX = SUBSCRIPTION_REJECTED;
const int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;

const ::google::protobuf::EnumDescriptor* ErrorCode_descriptor();
inline const ::std::string& ErrorCode_Name(ErrorCode value) {
  return ::google::protobuf::internal::NameOfEnum(
    ErrorCode_descriptor(), value);
}
inline bool ErrorCode_Parse(
    const ::std::string& name, ErrorCode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ErrorCode>(
    ErrorCode_descriptor(), name, value);
}
// ===================================================================

class PongV1 : public ::google::protobuf::Message {
 public:
  PongV1();
  virtual ~PongV1();

  PongV1(const PongV1& from);

  inline PongV1& operator=(const PongV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PongV1& default_instance();

  void Swap(PongV1* other);

  // implements Message ----------------------------------------------

  PongV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PongV1& from);
  void MergeFrom(const PongV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 70;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.PongV1)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static PongV1* default_instance_;
};
// -------------------------------------------------------------------

class FeatureSpecificationV1 : public ::google::protobuf::Message {
 public:
  FeatureSpecificationV1();
  virtual ~FeatureSpecificationV1();

  FeatureSpecificationV1(const FeatureSpecificationV1& from);

  inline FeatureSpecificationV1& operator=(const FeatureSpecificationV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FeatureSpecificationV1& default_instance();

  void Swap(FeatureSpecificationV1* other);

  // implements Message ----------------------------------------------

  FeatureSpecificationV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FeatureSpecificationV1& from);
  void MergeFrom(const FeatureSpecificationV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated uint32 supported_message_formats = 1;
  inline int supported_message_formats_size() const;
  inline void clear_supported_message_formats();
  static const int kSupportedMessageFormatsFieldNumber = 1;
  inline ::google::protobuf::uint32 supported_message_formats(int index) const;
  inline void set_supported_message_formats(int index, ::google::protobuf::uint32 value);
  inline void add_supported_message_formats(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      supported_message_formats() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_supported_message_formats();

  // repeated uint32 supported_request_types = 2;
  inline int supported_request_types_size() const;
  inline void clear_supported_request_types();
  static const int kSupportedRequestTypesFieldNumber = 2;
  inline ::google::protobuf::uint32 supported_request_types(int index) const;
  inline void set_supported_request_types(int index, ::google::protobuf::uint32 value);
  inline void add_supported_request_types(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      supported_request_types() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_supported_request_types();

  // repeated string supported_request_names = 3;
  inline int supported_request_names_size() const;
  inline void clear_supported_request_names();
  static const int kSupportedRequestNamesFieldNumber = 3;
  inline const ::std::string& supported_request_names(int index) const;
  inline ::std::string* mutable_supported_request_names(int index);
  inline void set_supported_request_names(int index, const ::std::string& value);
  inline void set_supported_request_names(int index, const char* value);
  inline void set_supported_request_names(int index, const char* value, size_t size);
  inline ::std::string* add_supported_request_names();
  inline void add_supported_request_names(const ::std::string& value);
  inline void add_supported_request_names(const char* value);
  inline void add_supported_request_names(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& supported_request_names() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_supported_request_names();

  // optional uint32 max_stream_segment_bytes = 4;
  inline bool has_max_stream_segment_bytes() const;
  inline void clear_max_stream_segment_bytes();
  static const int kMaxStreamSegmentBytesFieldNumber = 4;
  inline ::google::protobuf::uint32 max_stream_segment_bytes() const;
  inline void set_max_stream_segment_bytes(::google::protobuf::uint32 value);

  // optional uint32 max_stream_segment_envelopes = 5;
  inline bool has_max_stream_segment_envelopes() const;
  inline void clear_max_stream_segment_envelopes();
  static const int kMaxStreamSegmentEnvelopesFieldNumber = 5;
  inline ::google::protobuf::uint32 max_stream_segment_envelopes() const;
  inline void set_max_stream_segment_envelopes(::google::protobuf::uint32 value);

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 71;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.FeatureSpecificationV1)
 private:
  inline void set_has_max_stream_segment_bytes();
  inline void clear_has_max_stream_segment_bytes();
  inline void set_has_max_stream_segment_envelopes();
  inline void clear_has_max_stream_segment_envelopes();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > supported_message_formats_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > supported_request_types_;
  ::google::protobuf::RepeatedPtrField< ::std::string> supported_request_names_;
  ::google::protobuf::uint32 max_stream_segment_bytes_;
  ::google::protobuf::uint32 max_stream_segment_envelopes_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static FeatureSpecificationV1* default_instance_;
};
// -------------------------------------------------------------------

class StreamSegmentStartV1 : public ::google::protobuf::Message {
 public:
  StreamSegmentStartV1();
  virtual ~StreamSegmentStartV1();

  StreamSegmentStartV1(const StreamSegmentStartV1& from);

  inline StreamSegmentStartV1& operator=(const StreamSegmentStartV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const StreamSegmentStartV1& default_instance();

  void Swap(StreamSegmentStartV1* other);

  // implements Message ----------------------------------------------

  StreamSegmentStartV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StreamSegmentStartV1& from);
  void MergeFrom(const StreamSegmentStartV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string path = 1;
  inline bool has_path() const;
  inline void clear_path();
  static const int kPathFieldNumber = 1;
  inline const ::std::string& path() const;
  inline void set_path(const ::std::string& value);
  inline void set_path(const char* value);
  inline void set_path(const char* value, size_t size);
  inline ::std::string* mutable_path();
  inline ::std::string* release_path();

  // required uint64 offset = 2;
  inline bool has_offset() const;
  inline void clear_offset();
  static const int kOffsetFieldNumber = 2;
  inline ::google::protobuf::uint64 offset() const;
  inline void set_offset(::google::protobuf::uint64 value);

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 104;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.StreamSegmentStartV1)
 private:
  inline void set_has_path();
  inline void clear_has_path();
  inline void set_has_offset();
  inline void clear_has_offset();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* path_;
  ::google::protobuf::uint64 offset_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static StreamSegmentStartV1* default_instance_;
};
// -------------------------------------------------------------------

class StreamSegmentEndV1 : public ::google::protobuf::Message {
 public:
  StreamSegmentEndV1();
  virtual ~StreamSegmentEndV1();

  StreamSegmentEndV1(const StreamSegmentEndV1& from);

  inline StreamSegmentEndV1& operator=(const StreamSegmentEndV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const StreamSegmentEndV1& default_instance();

  void Swap(StreamSegmentEndV1* other);

  // implements Message ----------------------------------------------

  StreamSegmentEndV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StreamSegmentEndV1& from);
  void MergeFrom(const StreamSegmentEndV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint64 offset = 1;
  inline bool has_offset() const;
  inline void clear_offset();
  static const int kOffsetFieldNumber = 1;
  inline ::google::protobuf::uint64 offset() const;
  inline void set_offset(::google::protobuf::uint64 value);

  // required uint32 bytes_sent = 2;
  inline bool has_bytes_sent() const;
  inline void clear_bytes_sent();
  static const int kBytesSentFieldNumber = 2;
  inline ::google::protobuf::uint32 bytes_sent() const;
  inline void set_bytes_sent(::google::protobuf::uint32 value);

  // required uint32 envelopes_sent = 3;
  inline bool has_envelopes_sent() const;
  inline void clear_envelopes_sent();
  static const int kEnvelopesSentFieldNumber = 3;
  inline ::google::protobuf::uint32 envelopes_sent() const;
  inline void set_envelopes_sent(::google::protobuf::uint32 value);

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 105;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.StreamSegmentEndV1)
 private:
  inline void set_has_offset();
  inline void clear_has_offset();
  inline void set_has_bytes_sent();
  inline void clear_has_bytes_sent();
  inline void set_has_envelopes_sent();
  inline void clear_has_envelopes_sent();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint64 offset_;
  ::google::protobuf::uint32 bytes_sent_;
  ::google::protobuf::uint32 envelopes_sent_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static StreamSegmentEndV1* default_instance_;
};
// -------------------------------------------------------------------

class SubscriptionAcceptAckV1 : public ::google::protobuf::Message {
 public:
  SubscriptionAcceptAckV1();
  virtual ~SubscriptionAcceptAckV1();

  SubscriptionAcceptAckV1(const SubscriptionAcceptAckV1& from);

  inline SubscriptionAcceptAckV1& operator=(const SubscriptionAcceptAckV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SubscriptionAcceptAckV1& default_instance();

  void Swap(SubscriptionAcceptAckV1* other);

  // implements Message ----------------------------------------------

  SubscriptionAcceptAckV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SubscriptionAcceptAckV1& from);
  void MergeFrom(const SubscriptionAcceptAckV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bytes id = 1;
  inline bool has_id() const;
  inline void clear_id();
  static const int kIdFieldNumber = 1;
  inline const ::std::string& id() const;
  inline void set_id(const ::std::string& value);
  inline void set_id(const char* value);
  inline void set_id(const void* value, size_t size);
  inline ::std::string* mutable_id();
  inline ::std::string* release_id();

  // required uint32 ttl = 2;
  inline bool has_ttl() const;
  inline void clear_ttl();
  static const int kTtlFieldNumber = 2;
  inline ::google::protobuf::uint32 ttl() const;
  inline void set_ttl(::google::protobuf::uint32 value);

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 109;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.SubscriptionAcceptAckV1)
 private:
  inline void set_has_id();
  inline void clear_has_id();
  inline void set_has_ttl();
  inline void clear_has_ttl();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* id_;
  ::google::protobuf::uint32 ttl_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static SubscriptionAcceptAckV1* default_instance_;
};
// -------------------------------------------------------------------

class SubscriptionKeepaliveAckV1 : public ::google::protobuf::Message {
 public:
  SubscriptionKeepaliveAckV1();
  virtual ~SubscriptionKeepaliveAckV1();

  SubscriptionKeepaliveAckV1(const SubscriptionKeepaliveAckV1& from);

  inline SubscriptionKeepaliveAckV1& operator=(const SubscriptionKeepaliveAckV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SubscriptionKeepaliveAckV1& default_instance();

  void Swap(SubscriptionKeepaliveAckV1* other);

  // implements Message ----------------------------------------------

  SubscriptionKeepaliveAckV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SubscriptionKeepaliveAckV1& from);
  void MergeFrom(const SubscriptionKeepaliveAckV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bytes id = 1;
  inline bool has_id() const;
  inline void clear_id();
  static const int kIdFieldNumber = 1;
  inline const ::std::string& id() const;
  inline void set_id(const ::std::string& value);
  inline void set_id(const char* value);
  inline void set_id(const void* value, size_t size);
  inline ::std::string* mutable_id();
  inline ::std::string* release_id();

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 110;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.SubscriptionKeepaliveAckV1)
 private:
  inline void set_has_id();
  inline void clear_has_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static SubscriptionKeepaliveAckV1* default_instance_;
};
// -------------------------------------------------------------------

class SubscriptionStartV1 : public ::google::protobuf::Message {
 public:
  SubscriptionStartV1();
  virtual ~SubscriptionStartV1();

  SubscriptionStartV1(const SubscriptionStartV1& from);

  inline SubscriptionStartV1& operator=(const SubscriptionStartV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SubscriptionStartV1& default_instance();

  void Swap(SubscriptionStartV1* other);

  // implements Message ----------------------------------------------

  SubscriptionStartV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SubscriptionStartV1& from);
  void MergeFrom(const SubscriptionStartV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bytes id = 1;
  inline bool has_id() const;
  inline void clear_id();
  static const int kIdFieldNumber = 1;
  inline const ::std::string& id() const;
  inline void set_id(const ::std::string& value);
  inline void set_id(const char* value);
  inline void set_id(const void* value, size_t size);
  inline ::std::string* mutable_id();
  inline ::std::string* release_id();

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 107;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.SubscriptionStartV1)
 private:
  inline void set_has_id();
  inline void clear_has_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static SubscriptionStartV1* default_instance_;
};
// -------------------------------------------------------------------

class WriteAckV1 : public ::google::protobuf::Message {
 public:
  WriteAckV1();
  virtual ~WriteAckV1();

  WriteAckV1(const WriteAckV1& from);

  inline WriteAckV1& operator=(const WriteAckV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const WriteAckV1& default_instance();

  void Swap(WriteAckV1* other);

  // implements Message ----------------------------------------------

  WriteAckV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const WriteAckV1& from);
  void MergeFrom(const WriteAckV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 envelopes_written = 1;
  inline bool has_envelopes_written() const;
  inline void clear_envelopes_written();
  static const int kEnvelopesWrittenFieldNumber = 1;
  inline ::google::protobuf::uint32 envelopes_written() const;
  inline void set_envelopes_written(::google::protobuf::uint32 value);

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 108;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.WriteAckV1)
 private:
  inline void set_has_envelopes_written();
  inline void clear_has_envelopes_written();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 envelopes_written_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static WriteAckV1* default_instance_;
};
// -------------------------------------------------------------------

class PluginRegisterAckV1 : public ::google::protobuf::Message {
 public:
  PluginRegisterAckV1();
  virtual ~PluginRegisterAckV1();

  PluginRegisterAckV1(const PluginRegisterAckV1& from);

  inline PluginRegisterAckV1& operator=(const PluginRegisterAckV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PluginRegisterAckV1& default_instance();

  void Swap(PluginRegisterAckV1* other);

  // implements Message ----------------------------------------------

  PluginRegisterAckV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PluginRegisterAckV1& from);
  void MergeFrom(const PluginRegisterAckV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 114;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.PluginRegisterAckV1)
 private:
  inline void set_has_name();
  inline void clear_has_name();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static PluginRegisterAckV1* default_instance_;
};
// -------------------------------------------------------------------

class PluginUnregisterAckV1 : public ::google::protobuf::Message {
 public:
  PluginUnregisterAckV1();
  virtual ~PluginUnregisterAckV1();

  PluginUnregisterAckV1(const PluginUnregisterAckV1& from);

  inline PluginUnregisterAckV1& operator=(const PluginUnregisterAckV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PluginUnregisterAckV1& default_instance();

  void Swap(PluginUnregisterAckV1* other);

  // implements Message ----------------------------------------------

  PluginUnregisterAckV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PluginUnregisterAckV1& from);
  void MergeFrom(const PluginUnregisterAckV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 117;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.PluginUnregisterAckV1)
 private:
  inline void set_has_name();
  inline void clear_has_name();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static PluginUnregisterAckV1* default_instance_;
};
// -------------------------------------------------------------------

class PluginStatusV1 : public ::google::protobuf::Message {
 public:
  PluginStatusV1();
  virtual ~PluginStatusV1();

  PluginStatusV1(const PluginStatusV1& from);

  inline PluginStatusV1& operator=(const PluginStatusV1& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PluginStatusV1& default_instance();

  void Swap(PluginStatusV1* other);

  // implements Message ----------------------------------------------

  PluginStatusV1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const PluginStatusV1& from);
  void MergeFrom(const PluginStatusV1& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .zippylog.protocol.PluginStateV1 state = 1;
  inline int state_size() const;
  inline void clear_state();
  static const int kStateFieldNumber = 1;
  inline const ::zippylog::protocol::PluginStateV1& state(int index) const;
  inline ::zippylog::protocol::PluginStateV1* mutable_state(int index);
  inline ::zippylog::protocol::PluginStateV1* add_state();
  inline const ::google::protobuf::RepeatedPtrField< ::zippylog::protocol::PluginStateV1 >&
      state() const;
  inline ::google::protobuf::RepeatedPtrField< ::zippylog::protocol::PluginStateV1 >*
      mutable_state();

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 115;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.PluginStatusV1)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::zippylog::protocol::PluginStateV1 > state_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static PluginStatusV1* default_instance_;
};
// -------------------------------------------------------------------

class Error : public ::google::protobuf::Message {
 public:
  Error();
  virtual ~Error();

  Error(const Error& from);

  inline Error& operator=(const Error& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Error& default_instance();

  void Swap(Error* other);

  // implements Message ----------------------------------------------

  Error* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Error& from);
  void MergeFrom(const Error& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .zippylog.protocol.response.ErrorCode code = 1;
  inline bool has_code() const;
  inline void clear_code();
  static const int kCodeFieldNumber = 1;
  inline zippylog::protocol::response::ErrorCode code() const;
  inline void set_code(zippylog::protocol::response::ErrorCode value);

  // optional string msg = 2;
  inline bool has_msg() const;
  inline void clear_msg();
  static const int kMsgFieldNumber = 2;
  inline const ::std::string& msg() const;
  inline void set_msg(const ::std::string& value);
  inline void set_msg(const char* value);
  inline void set_msg(const char* value, size_t size);
  inline ::std::string* mutable_msg();
  inline ::std::string* release_msg();

  static const ::google::protobuf::uint32 zippylog_namespace = 1;
  static const ::google::protobuf::uint32 zippylog_enumeration = 69;

  bool add_to_envelope(::zippylog::Envelope *envelope);
  bool add_to_envelope(::zippylog::Envelope &envelope);
  // @@protoc_insertion_point(class_scope:zippylog.protocol.response.Error)
 private:
  inline void set_has_code();
  inline void clear_has_code();
  inline void set_has_msg();
  inline void clear_has_msg();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* msg_;
  int code_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_AssignDesc_zippylog_2fprotocol_2fresponse_2eproto();
  friend void protobuf_ShutdownFile_zippylog_2fprotocol_2fresponse_2eproto();

  void InitAsDefaultInstance();
  static Error* default_instance_;
};
// ===================================================================

// ===================================================================

// PongV1

// -------------------------------------------------------------------

// FeatureSpecificationV1

// repeated uint32 supported_message_formats = 1;
inline int FeatureSpecificationV1::supported_message_formats_size() const {
  return supported_message_formats_.size();
}
inline void FeatureSpecificationV1::clear_supported_message_formats() {
  supported_message_formats_.Clear();
}
inline ::google::protobuf::uint32 FeatureSpecificationV1::supported_message_formats(int index) const {
  return supported_message_formats_.Get(index);
}
inline void FeatureSpecificationV1::set_supported_message_formats(int index, ::google::protobuf::uint32 value) {
  supported_message_formats_.Set(index, value);
}
inline void FeatureSpecificationV1::add_supported_message_formats(::google::protobuf::uint32 value) {
  supported_message_formats_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
FeatureSpecificationV1::supported_message_formats() const {
  return supported_message_formats_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
FeatureSpecificationV1::mutable_supported_message_formats() {
  return &supported_message_formats_;
}

// repeated uint32 supported_request_types = 2;
inline int FeatureSpecificationV1::supported_request_types_size() const {
  return supported_request_types_.size();
}
inline void FeatureSpecificationV1::clear_supported_request_types() {
  supported_request_types_.Clear();
}
inline ::google::protobuf::uint32 FeatureSpecificationV1::supported_request_types(int index) const {
  return supported_request_types_.Get(index);
}
inline void FeatureSpecificationV1::set_supported_request_types(int index, ::google::protobuf::uint32 value) {
  supported_request_types_.Set(index, value);
}
inline void FeatureSpecificationV1::add_supported_request_types(::google::protobuf::uint32 value) {
  supported_request_types_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
FeatureSpecificationV1::supported_request_types() const {
  return supported_request_types_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
FeatureSpecificationV1::mutable_supported_request_types() {
  return &supported_request_types_;
}

// repeated string supported_request_names = 3;
inline int FeatureSpecificationV1::supported_request_names_size() const {
  return supported_request_names_.size();
}
inline void FeatureSpecificationV1::clear_supported_request_names() {
  supported_request_names_.Clear();
}
inline const ::std::string& FeatureSpecificationV1::supported_request_names(int index) const {
  return supported_request_names_.Get(index);
}
inline ::std::string* FeatureSpecificationV1::mutable_supported_request_names(int index) {
  return supported_request_names_.Mutable(index);
}
inline void FeatureSpecificationV1::set_supported_request_names(int index, const ::std::string& value) {
  supported_request_names_.Mutable(index)->assign(value);
}
inline void FeatureSpecificationV1::set_supported_request_names(int index, const char* value) {
  supported_request_names_.Mutable(index)->assign(value);
}
inline void FeatureSpecificationV1::set_supported_request_names(int index, const char* value, size_t size) {
  supported_request_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* FeatureSpecificationV1::add_supported_request_names() {
  return supported_request_names_.Add();
}
inline void FeatureSpecificationV1::add_supported_request_names(const ::std::string& value) {
  supported_request_names_.Add()->assign(value);
}
inline void FeatureSpecificationV1::add_supported_request_names(const char* value) {
  supported_request_names_.Add()->assign(value);
}
inline void FeatureSpecificationV1::add_supported_request_names(const char* value, size_t size) {
  supported_request_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
FeatureSpecificationV1::supported_request_names() const {
  return supported_request_names_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
FeatureSpecificationV1::mutable_supported_request_names() {
  return &supported_request_names_;
}

// optional uint32 max_stream_segment_bytes = 4;
inline bool FeatureSpecificationV1::has_max_stream_segment_bytes() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void FeatureSpecificationV1::set_has_max_stream_segment_bytes() {
  _has_bits_[0] |= 0x00000008u;
}
inline void FeatureSpecificationV1::clear_has_max_stream_segment_bytes() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void FeatureSpecificationV1::clear_max_stream_segment_bytes() {
  max_stream_segment_bytes_ = 0u;
  clear_has_max_stream_segment_bytes();
}
inline ::google::protobuf::uint32 FeatureSpecificationV1::max_stream_segment_bytes() const {
  return max_stream_segment_bytes_;
}
inline void FeatureSpecificationV1::set_max_stream_segment_bytes(::google::protobuf::uint32 value) {
  set_has_max_stream_segment_bytes();
  max_stream_segment_bytes_ = value;
}

// optional uint32 max_stream_segment_envelopes = 5;
inline bool FeatureSpecificationV1::has_max_stream_segment_envelopes() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void FeatureSpecificationV1::set_has_max_stream_segment_envelopes() {
  _has_bits_[0] |= 0x00000010u;
}
inline void FeatureSpecificationV1::clear_has_max_stream_segment_envelopes() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void FeatureSpecificationV1::clear_max_stream_segment_envelopes() {
  max_stream_segment_envelopes_ = 0u;
  clear_has_max_stream_segment_envelopes();
}
inline ::google::protobuf::uint32 FeatureSpecificationV1::max_stream_segment_envelopes() const {
  return max_stream_segment_envelopes_;
}
inline void FeatureSpecificationV1::set_max_stream_segment_envelopes(::google::protobuf::uint32 value) {
  set_has_max_stream_segment_envelopes();
  max_stream_segment_envelopes_ = value;
}

// -------------------------------------------------------------------

// StreamSegmentStartV1

// required string path = 1;
inline bool StreamSegmentStartV1::has_path() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StreamSegmentStartV1::set_has_path() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StreamSegmentStartV1::clear_has_path() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StreamSegmentStartV1::clear_path() {
  if (path_ != &::google::protobuf::internal::kEmptyString) {
    path_->clear();
  }
  clear_has_path();
}
inline const ::std::string& StreamSegmentStartV1::path() const {
  return *path_;
}
inline void StreamSegmentStartV1::set_path(const ::std::string& value) {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  path_->assign(value);
}
inline void StreamSegmentStartV1::set_path(const char* value) {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  path_->assign(value);
}
inline void StreamSegmentStartV1::set_path(const char* value, size_t size) {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  path_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* StreamSegmentStartV1::mutable_path() {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  return path_;
}
inline ::std::string* StreamSegmentStartV1::release_path() {
  clear_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = path_;
    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required uint64 offset = 2;
inline bool StreamSegmentStartV1::has_offset() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StreamSegmentStartV1::set_has_offset() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StreamSegmentStartV1::clear_has_offset() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StreamSegmentStartV1::clear_offset() {
  offset_ = GOOGLE_ULONGLONG(0);
  clear_has_offset();
}
inline ::google::protobuf::uint64 StreamSegmentStartV1::offset() const {
  return offset_;
}
inline void StreamSegmentStartV1::set_offset(::google::protobuf::uint64 value) {
  set_has_offset();
  offset_ = value;
}

// -------------------------------------------------------------------

// StreamSegmentEndV1

// required uint64 offset = 1;
inline bool StreamSegmentEndV1::has_offset() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StreamSegmentEndV1::set_has_offset() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StreamSegmentEndV1::clear_has_offset() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StreamSegmentEndV1::clear_offset() {
  offset_ = GOOGLE_ULONGLONG(0);
  clear_has_offset();
}
inline ::google::protobuf::uint64 StreamSegmentEndV1::offset() const {
  return offset_;
}
inline void StreamSegmentEndV1::set_offset(::google::protobuf::uint64 value) {
  set_has_offset();
  offset_ = value;
}

// required uint32 bytes_sent = 2;
inline bool StreamSegmentEndV1::has_bytes_sent() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StreamSegmentEndV1::set_has_bytes_sent() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StreamSegmentEndV1::clear_has_bytes_sent() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StreamSegmentEndV1::clear_bytes_sent() {
  bytes_sent_ = 0u;
  clear_has_bytes_sent();
}
inline ::google::protobuf::uint32 StreamSegmentEndV1::bytes_sent() const {
  return bytes_sent_;
}
inline void StreamSegmentEndV1::set_bytes_sent(::google::protobuf::uint32 value) {
  set_has_bytes_sent();
  bytes_sent_ = value;
}

// required uint32 envelopes_sent = 3;
inline bool StreamSegmentEndV1::has_envelopes_sent() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void StreamSegmentEndV1::set_has_envelopes_sent() {
  _has_bits_[0] |= 0x00000004u;
}
inline void StreamSegmentEndV1::clear_has_envelopes_sent() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void StreamSegmentEndV1::clear_envelopes_sent() {
  envelopes_sent_ = 0u;
  clear_has_envelopes_sent();
}
inline ::google::protobuf::uint32 StreamSegmentEndV1::envelopes_sent() const {
  return envelopes_sent_;
}
inline void StreamSegmentEndV1::set_envelopes_sent(::google::protobuf::uint32 value) {
  set_has_envelopes_sent();
  envelopes_sent_ = value;
}

// -------------------------------------------------------------------

// SubscriptionAcceptAckV1

// required bytes id = 1;
inline bool SubscriptionAcceptAckV1::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SubscriptionAcceptAckV1::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SubscriptionAcceptAckV1::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SubscriptionAcceptAckV1::clear_id() {
  if (id_ != &::google::protobuf::internal::kEmptyString) {
    id_->clear();
  }
  clear_has_id();
}
inline const ::std::string& SubscriptionAcceptAckV1::id() const {
  return *id_;
}
inline void SubscriptionAcceptAckV1::set_id(const ::std::string& value) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(value);
}
inline void SubscriptionAcceptAckV1::set_id(const char* value) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(value);
}
inline void SubscriptionAcceptAckV1::set_id(const void* value, size_t size) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SubscriptionAcceptAckV1::mutable_id() {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  return id_;
}
inline ::std::string* SubscriptionAcceptAckV1::release_id() {
  clear_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = id_;
    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required uint32 ttl = 2;
inline bool SubscriptionAcceptAckV1::has_ttl() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SubscriptionAcceptAckV1::set_has_ttl() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SubscriptionAcceptAckV1::clear_has_ttl() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SubscriptionAcceptAckV1::clear_ttl() {
  ttl_ = 0u;
  clear_has_ttl();
}
inline ::google::protobuf::uint32 SubscriptionAcceptAckV1::ttl() const {
  return ttl_;
}
inline void SubscriptionAcceptAckV1::set_ttl(::google::protobuf::uint32 value) {
  set_has_ttl();
  ttl_ = value;
}

// -------------------------------------------------------------------

// SubscriptionKeepaliveAckV1

// required bytes id = 1;
inline bool SubscriptionKeepaliveAckV1::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SubscriptionKeepaliveAckV1::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SubscriptionKeepaliveAckV1::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SubscriptionKeepaliveAckV1::clear_id() {
  if (id_ != &::google::protobuf::internal::kEmptyString) {
    id_->clear();
  }
  clear_has_id();
}
inline const ::std::string& SubscriptionKeepaliveAckV1::id() const {
  return *id_;
}
inline void SubscriptionKeepaliveAckV1::set_id(const ::std::string& value) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(value);
}
inline void SubscriptionKeepaliveAckV1::set_id(const char* value) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(value);
}
inline void SubscriptionKeepaliveAckV1::set_id(const void* value, size_t size) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SubscriptionKeepaliveAckV1::mutable_id() {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  return id_;
}
inline ::std::string* SubscriptionKeepaliveAckV1::release_id() {
  clear_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = id_;
    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// -------------------------------------------------------------------

// SubscriptionStartV1

// required bytes id = 1;
inline bool SubscriptionStartV1::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SubscriptionStartV1::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SubscriptionStartV1::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SubscriptionStartV1::clear_id() {
  if (id_ != &::google::protobuf::internal::kEmptyString) {
    id_->clear();
  }
  clear_has_id();
}
inline const ::std::string& SubscriptionStartV1::id() const {
  return *id_;
}
inline void SubscriptionStartV1::set_id(const ::std::string& value) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(value);
}
inline void SubscriptionStartV1::set_id(const char* value) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(value);
}
inline void SubscriptionStartV1::set_id(const void* value, size_t size) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SubscriptionStartV1::mutable_id() {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  return id_;
}
inline ::std::string* SubscriptionStartV1::release_id() {
  clear_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = id_;
    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// -------------------------------------------------------------------

// WriteAckV1

// required uint32 envelopes_written = 1;
inline bool WriteAckV1::has_envelopes_written() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WriteAckV1::set_has_envelopes_written() {
  _has_bits_[0] |= 0x00000001u;
}
inline void WriteAckV1::clear_has_envelopes_written() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void WriteAckV1::clear_envelopes_written() {
  envelopes_written_ = 0u;
  clear_has_envelopes_written();
}
inline ::google::protobuf::uint32 WriteAckV1::envelopes_written() const {
  return envelopes_written_;
}
inline void WriteAckV1::set_envelopes_written(::google::protobuf::uint32 value) {
  set_has_envelopes_written();
  envelopes_written_ = value;
}

// -------------------------------------------------------------------

// PluginRegisterAckV1

// required string name = 1;
inline bool PluginRegisterAckV1::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PluginRegisterAckV1::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PluginRegisterAckV1::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PluginRegisterAckV1::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& PluginRegisterAckV1::name() const {
  return *name_;
}
inline void PluginRegisterAckV1::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void PluginRegisterAckV1::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void PluginRegisterAckV1::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* PluginRegisterAckV1::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* PluginRegisterAckV1::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// -------------------------------------------------------------------

// PluginUnregisterAckV1

// required string name = 1;
inline bool PluginUnregisterAckV1::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PluginUnregisterAckV1::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PluginUnregisterAckV1::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PluginUnregisterAckV1::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& PluginUnregisterAckV1::name() const {
  return *name_;
}
inline void PluginUnregisterAckV1::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void PluginUnregisterAckV1::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void PluginUnregisterAckV1::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* PluginUnregisterAckV1::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* PluginUnregisterAckV1::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// -------------------------------------------------------------------

// PluginStatusV1

// repeated .zippylog.protocol.PluginStateV1 state = 1;
inline int PluginStatusV1::state_size() const {
  return state_.size();
}
inline void PluginStatusV1::clear_state() {
  state_.Clear();
}
inline const ::zippylog::protocol::PluginStateV1& PluginStatusV1::state(int index) const {
  return state_.Get(index);
}
inline ::zippylog::protocol::PluginStateV1* PluginStatusV1::mutable_state(int index) {
  return state_.Mutable(index);
}
inline ::zippylog::protocol::PluginStateV1* PluginStatusV1::add_state() {
  return state_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::zippylog::protocol::PluginStateV1 >&
PluginStatusV1::state() const {
  return state_;
}
inline ::google::protobuf::RepeatedPtrField< ::zippylog::protocol::PluginStateV1 >*
PluginStatusV1::mutable_state() {
  return &state_;
}

// -------------------------------------------------------------------

// Error

// optional .zippylog.protocol.response.ErrorCode code = 1;
inline bool Error::has_code() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Error::set_has_code() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Error::clear_has_code() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Error::clear_code() {
  code_ = 1;
  clear_has_code();
}
inline zippylog::protocol::response::ErrorCode Error::code() const {
  return static_cast< zippylog::protocol::response::ErrorCode >(code_);
}
inline void Error::set_code(zippylog::protocol::response::ErrorCode value) {
  GOOGLE_DCHECK(zippylog::protocol::response::ErrorCode_IsValid(value));
  set_has_code();
  code_ = value;
}

// optional string msg = 2;
inline bool Error::has_msg() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Error::set_has_msg() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Error::clear_has_msg() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Error::clear_msg() {
  if (msg_ != &::google::protobuf::internal::kEmptyString) {
    msg_->clear();
  }
  clear_has_msg();
}
inline const ::std::string& Error::msg() const {
  return *msg_;
}
inline void Error::set_msg(const ::std::string& value) {
  set_has_msg();
  if (msg_ == &::google::protobuf::internal::kEmptyString) {
    msg_ = new ::std::string;
  }
  msg_->assign(value);
}
inline void Error::set_msg(const char* value) {
  set_has_msg();
  if (msg_ == &::google::protobuf::internal::kEmptyString) {
    msg_ = new ::std::string;
  }
  msg_->assign(value);
}
inline void Error::set_msg(const char* value, size_t size) {
  set_has_msg();
  if (msg_ == &::google::protobuf::internal::kEmptyString) {
    msg_ = new ::std::string;
  }
  msg_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Error::mutable_msg() {
  set_has_msg();
  if (msg_ == &::google::protobuf::internal::kEmptyString) {
    msg_ = new ::std::string;
  }
  return msg_;
}
inline ::std::string* Error::release_msg() {
  clear_has_msg();
  if (msg_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = msg_;
    msg_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// @@protoc_insertion_point(namespace_scope)

}  // namespace response
}  // namespace protocol
}  // namespace zippylog

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< zippylog::protocol::response::ErrorCode>() {
  return zippylog::protocol::response::ErrorCode_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_zippylog_2fprotocol_2fresponse_2eproto__INCLUDED


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Trans. Br. mycol. Soc. 27: 96 (1944)

#### Original name
Amphicypellus elegans Ingold, 1944

### Remarks
null


text:
<?php

defined('BASEPATH') OR exit('No direct script access allowed');

class Welcome extends Application
{
    function __construct()
    {
        parent::__construct();
    }

    /**
     * Homepage for our app
     */
    public function index()
    {
        // this is the view we want shown
        $this->data['pagebody'] = 'homepage';

        // build the list of authors, to pass on to our view
        $source = $this->quotes->all();
        $authors = array ();
        foreach ($source as $record)
        {
            $authors[] = array ('who' => $record['who'], 'mug' => $record['mug'], 'href' => $record['where']);
        }
        $this->data['authors'] = $authors;

        $this->render();
    }

    /**
     * A page that contains Elayne Boosler's quote and image
     */
    public function shucks()
    {
        // this is the view we want shown
        $this->data['pagebody'] = 'justone';

        // Load the data of Elayne Boosler, store in data array
        $record = $this->quotes->get(2);
        $this->data = array_merge($this->data, $record);

        $this->render();
    }
}


text:
using System.Diagnostics;
using System.Globalization;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Forms;
using Microsoft.AspNetCore.Components.Rendering;

namespace Meziantou.AspNetCore.Components;

public class InputUrl<TValue> : InputBase<TValue>
{
    [Parameter] public string ParsingErrorMessage { get; set; } = string.Empty;
    [DisallowNull] public ElementReference? Element { get; protected set; }

    protected override void BuildRenderTree(RenderTreeBuilder builder)
    {
        builder.OpenElement(0, "input");
        builder.AddMultipleAttributes(1, AdditionalAttributes);
        builder.AddAttribute(2, "type", "url");
        builder.AddAttribute(3, "class", CssClass);
        builder.AddAttribute(4, "value", BindConverter.FormatValue(CurrentValueAsString));
        builder.AddAttribute(5, "onchange", EventCallback.Factory.CreateBinder<string?>(this, value => CurrentValueAsString = value, CurrentValueAsString));
        builder.AddElementReferenceCapture(6, inputReference => Element = inputReference);
        builder.CloseElement();
    }

    /// <inheritdoc />
    protected override string FormatValueAsString(TValue? value)
    {
        return value switch
        {
            string str => str,
            Uri uri => uri.ToString(),
            _ => string.Empty,// Handles null for Nullable<DateTime>, etc.
        };
    }

    /// <inheritdoc />
    protected override bool TryParseValueFromString(string? value, [MaybeNullWhen(false)] out TValue result, [NotNullWhen(false)] out string? validationErrorMessage)
    {
        // Unwrap nullable types. We don't have to deal with receiving empty values for nullable
        // types here, because the underlying InputBase already covers that.
        var targetType = typeof(TValue);

        bool success;
        if (targetType == typeof(string))
        {
            success = TryParseString(value, out result);
        }
        else if (targetType == typeof(Uri))
        {
            success = TryParseUri(value, out result);
        }
        else
        {
            throw new InvalidOperationException($"The type '{targetType}' is not a supported date type.");
        }

        if (success)
        {
            Debug.Assert(result != null);
            validationErrorMessage = null;
            return true;
        }
        else
        {
            validationErrorMessage = string.Format(CultureInfo.CurrentCulture, ParsingErrorMessage, FieldIdentifier.FieldName);
            return false;
        }
    }

    private static bool TryParseString(string? value, out TValue? result)
    {
        if (value != null)
        {
            result = (TValue)(object)value;
            return true;
        }
        else
        {
            result = default;
            return false;
        }
    }

    private static bool TryParseUri(string? value, out TValue? result)
    {
        if (Uri.TryCreate(value, UriKind.RelativeOrAbsolute, out var uri))
        {
            result = (TValue)(object)uri;
            return true;
        }
        else
        {
            result = default;
            return false;
        }
    }
}