organicmaps/protobuf
13
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity Actions

Wiping slate clean to start again with new layout.

Browse source
This commit is contained in:
Jon Skeet 2008-10-22 13:18:49 +01:00
parent e60ce8bfaf
commit f0589506c9
440 changed files with 0 additions and 149156 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
CHANGES.txt
View file

@ -1,3 +0,0 @@
2008-07-07 version 2.0.0:
* First public release.

49
CONTRIBUTORS.txt
View file

@ -1,49 +0,0 @@
This file contains a list of people who have made large contributions
to the public version of Protocol Buffers.
Original Protocol Buffers design and implementation:
Sanjay Ghemawat <sanjay@google.com>
Jeff Dean <jeff@google.com>
Daniel Dulitz <daniel@google.com>
Craig Silverstein
Paul Haahr <haahr@google.com>
Corey Anderson <corin@google.com>
(and many others)
Proto2 C++ and Java primary author:
Kenton Varda <kenton@google.com>
Proto2 Python primary authors:
Will Robinson <robinson@google.com>
Petar Petrov <petar@google.com>
Large code contributions:
Joseph Schorr <jschorr@google.com>
Wenbo Zhu <wenboz@google.com>
Large quantity of code reviews:
Scott Bruce <sbruce@google.com>
Frank Yellin
Neal Norwitz <nnorwitz@google.com>
Jeffrey Yasskin <jyasskin@google.com>
Ambrose Feinstein <ambrose@google.com>
Documentation:
Lisa Carey <lcarey@google.com>
Maven packaging:
Gregory Kick <gak@google.com>
Non-Google patch contributors:
Kevin Ko <kevin.s.ko@gmail.com>
* Small patch to handle trailing slashes in --proto_path flag.
Johan Euphrosine <proppy@aminche.com>
* Small patch to fix Pyhton CallMethod().
Ulrich Kunitz <kune@deine-taler.de>
* Small optimizations to Python serialization.
Leandro Lucarella <llucax@gmail.com>
* VI syntax highlighting tweaks.
* Fix compiler to not make output executable.
Dilip Joseph <dilip.antony.joseph@gmail.com>
* Heuristic detection of sub-messages when printing unknown fields in
text format.

202
COPYING.txt
View file

@ -1,202 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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.

42
CSHARP-README.txt
View file

@ -1,42 +0,0 @@
Readme for the C#/.NET implementation of Protocol Buffers
Copyright 2008 Google Inc.
http://code.google.com/apis/protocolbuffers/
and
http://github.com/jskeet/dotnet-protobufs
(This will eventually be written up into a full tutorial etc.)
Differences with respect to the Java API
----------------------------------------
Many of the changes are obvious "making it more like .NET", but
others are more subtle.
o Properties and indexers are used reasonably extensively.
o newFoo becomes CreateFoo everywhere.
o Classes are broken up much more - for instance, there are
namespaces for descriptors and field accessors, just to make it
easier to see what's going on.
o There's a mixture of generic and non-generic code. This
is interesting (at least if you're a language nerd). Java's generics
are somewhat different to those of .NET, partly due to type erasure
but in other ways too. .NET allows types to be overloaded by the
number of generic parameters, but there's no such thing as the
"raw" type of a generic type. Combining these two facts, I've
ended up with two interfaces for messages, and two for builders -
in each case, a non-generic one and a generic one which derives
from the generic one. Where the members clash (e.g. IBuilder.Build
and IBuilder<TMessage>.Build vary only by return type) the
implementations use explicit interface implementation to provide
the most useful method in most cases. This is very much like
the normal implementation of IEnumerable<T> which extends
IEnumerable. As an aside, this becomes a pain when trying to
create "the read-only version of this list, whose type I don't
know but I know it's a List<something>". Oh for mumble types.
o Nested types always end up under a "Types" static class which
is merely present to avoid name clashes.
o FileDescriptor.FindByName has been made generic to allow simple
type-safe searching for any nested type.
o No enum.valueOf for enums (due to them being simple C# enums)
o Public Builder constructors to aid C# object/collection initializers

237
INSTALL.txt
View file

@ -1,237 +0,0 @@
This file contains detailed but generic information on building and
installing the C++ part of this project. For shorter instructions,
as well as instructions for compiling and installing the Java or
Python parts, see README.
======================================================================
Copyright 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software
Foundation, Inc.
This file is free documentation; the Free Software Foundation gives
unlimited permission to copy, distribute and modify it.
Basic Installation
==================
These are generic installation instructions.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses
those values to create a `Makefile' in each directory of the package.
It may also create one or more `.h' files containing system-dependent
definitions. Finally, it creates a shell script `config.status' that
you can run in the future to recreate the current configuration, and a
file `config.log' containing compiler output (useful mainly for
debugging `configure').
It can also use an optional file (typically called `config.cache'
and enabled with `--cache-file=config.cache' or simply `-C') that saves
the results of its tests to speed up reconfiguring. (Caching is
disabled by default to prevent problems with accidental use of stale
cache files.)
If you need to do unusual things to compile the package, please try
to figure out how `configure' could check whether to do them, and mail
diffs or instructions to the address given in the `README' so they can
be considered for the next release. If you are using the cache, and at
some point `config.cache' contains results you don't want to keep, you
may remove or edit it.
The file `configure.ac' (or `configure.in') is used to create
`configure' by a program called `autoconf'. You only need
`configure.ac' if you want to change it or regenerate `configure' using
a newer version of `autoconf'.
The simplest way to compile this package is:
1. `cd' to the directory containing the package's source code and type
`./configure' to configure the package for your system. If you're
using `csh' on an old version of System V, you might need to type
`sh ./configure' instead to prevent `csh' from trying to execute
`configure' itself.
Running `configure' takes awhile. While running, it prints some
messages telling which features it is checking for.
2. Type `make' to compile the package.
3. Optionally, type `make check' to run any self-tests that come with
the package.
4. Type `make install' to install the programs and any data files and
documentation.
5. You can remove the program binaries and object files from the
source code directory by typing `make clean'. To also remove the
files that `configure' created (so you can compile the package for
a different kind of computer), type `make distclean'. There is
also a `make maintainer-clean' target, but that is intended mainly
for the package's developers. If you use it, you may have to get
all sorts of other programs in order to regenerate files that came
with the distribution.
Compilers and Options
=====================
Some systems require unusual options for compilation or linking that
the `configure' script does not know about. Run `./configure --help'
for details on some of the pertinent environment variables.
You can give `configure' initial values for configuration parameters
by setting variables in the command line or in the environment. Here
is an example:
./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
*Note Defining Variables::, for more details.
Compiling For Multiple Architectures
====================================
You can compile the package for more than one kind of computer at the
same time, by placing the object files for each architecture in their
own directory. To do this, you must use a version of `make' that
supports the `VPATH' variable, such as GNU `make'. `cd' to the
directory where you want the object files and executables to go and run
the `configure' script. `configure' automatically checks for the
source code in the directory that `configure' is in and in `..'.
If you have to use a `make' that does not support the `VPATH'
variable, you have to compile the package for one architecture at a
time in the source code directory. After you have installed the
package for one architecture, use `make distclean' before reconfiguring
for another architecture.
Installation Names
==================
By default, `make install' will install the package's files in
`/usr/local/bin', `/usr/local/man', etc. You can specify an
installation prefix other than `/usr/local' by giving `configure' the
option `--prefix=PATH'.
You can specify separate installation prefixes for
architecture-specific files and architecture-independent files. If you
give `configure' the option `--exec-prefix=PATH', the package will use
PATH as the prefix for installing programs and libraries.
Documentation and other data files will still use the regular prefix.
In addition, if you use an unusual directory layout you can give
options like `--bindir=PATH' to specify different values for particular
kinds of files. Run `configure --help' for a list of the directories
you can set and what kinds of files go in them.
If the package supports it, you can cause programs to be installed
with an extra prefix or suffix on their names by giving `configure' the
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
Optional Features
=================
Some packages pay attention to `--enable-FEATURE' options to
`configure', where FEATURE indicates an optional part of the package.
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
is something like `gnu-as' or `x' (for the X Window System). The
`README' should mention any `--enable-' and `--with-' options that the
package recognizes.
For packages that use the X Window System, `configure' can usually
find the X include and library files automatically, but if it doesn't,
you can use the `configure' options `--x-includes=DIR' and
`--x-libraries=DIR' to specify their locations.
Specifying the System Type
==========================
There may be some features `configure' cannot figure out
automatically, but needs to determine by the type of machine the package
will run on. Usually, assuming the package is built to be run on the
_same_ architectures, `configure' can figure that out, but if it prints
a message saying it cannot guess the machine type, give it the
`--build=TYPE' option. TYPE can either be a short name for the system
type, such as `sun4', or a canonical name which has the form:
CPU-COMPANY-SYSTEM
where SYSTEM can have one of these forms:
OS KERNEL-OS
See the file `config.sub' for the possible values of each field. If
`config.sub' isn't included in this package, then this package doesn't
need to know the machine type.
If you are _building_ compiler tools for cross-compiling, you should
use the `--target=TYPE' option to select the type of system they will
produce code for.
If you want to _use_ a cross compiler, that generates code for a
platform different from the build platform, you should specify the
"host" platform (i.e., that on which the generated programs will
eventually be run) with `--host=TYPE'.
Sharing Defaults
================
If you want to set default values for `configure' scripts to share,
you can create a site shell script called `config.site' that gives
default values for variables like `CC', `cache_file', and `prefix'.
`configure' looks for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists. Or, you can set the
`CONFIG_SITE' environment variable to the location of the site script.
A warning: not all `configure' scripts look for a site script.
Defining Variables
==================
Variables not defined in a site shell script can be set in the
environment passed to `configure'. However, some packages may run
configure again during the build, and the customized values of these
variables may be lost. In order to avoid this problem, you should set
them in the `configure' command line, using `VAR=value'. For example:
./configure CC=/usr/local2/bin/gcc
will cause the specified gcc to be used as the C compiler (unless it is
overridden in the site shell script).
`configure' Invocation
======================
`configure' recognizes the following options to control how it
operates.
`--help'
`-h'
Print a summary of the options to `configure', and exit.
`--version'
`-V'
Print the version of Autoconf used to generate the `configure'
script, and exit.
`--cache-file=FILE'
Enable the cache: use and save the results of the tests in FILE,
traditionally `config.cache'. FILE defaults to `/dev/null' to
disable caching.
`--config-cache'
`-C'
Alias for `--cache-file=config.cache'.
`--quiet'
`--silent'
`-q'
Do not print messages saying which checks are being made. To
suppress all normal output, redirect it to `/dev/null' (any error
messages will still be shown).
`--srcdir=DIR'
Look for the package's source code in directory DIR. Usually
`configure' can determine that directory automatically.
`configure' also accepts some other, not widely useful, options. Run
`configure --help' for more details.

121
Makefile.am
View file

@ -1,121 +0,0 @@
## Process this file with automake to produce Makefile.in
ACLOCAL_AMFLAGS = -I m4
if MONO
SUBDIRS = src csharp
else
SUBDIRS = src
endif
EXTRA_DIST = \
autogen.sh \
generate_descriptor_proto.sh \
README.txt \
INSTALL.txt \
COPYING.txt \
CONTRIBUTORS.txt \
CHANGES.txt \
editors/README.txt \
editors/proto.vim \
vsprojects/config.h \
vsprojects/extract_includes.bat \
vsprojects/libprotobuf.vcproj \
vsprojects/libprotoc.vcproj \
vsprojects/protobuf.sln \
vsprojects/protoc.vcproj \
vsprojects/readme.txt \
vsprojects/tests.vcproj \
vsprojects/convert2008to2005.sh \
examples/README.txt \
examples/Makefile \
examples/addressbook.proto \
examples/add_person.cc \
examples/list_people.cc \
examples/AddPerson.java \
examples/ListPeople.java \
examples/add_person.py \
examples/list_people.py \
java/src/main/java/com/google/protobuf/AbstractMessage.java \
java/src/main/java/com/google/protobuf/ByteString.java \
java/src/main/java/com/google/protobuf/CodedInputStream.java \
java/src/main/java/com/google/protobuf/CodedOutputStream.java \
java/src/main/java/com/google/protobuf/Descriptors.java \
java/src/main/java/com/google/protobuf/DynamicMessage.java \
java/src/main/java/com/google/protobuf/ExtensionRegistry.java \
java/src/main/java/com/google/protobuf/FieldSet.java \
java/src/main/java/com/google/protobuf/GeneratedMessage.java \
java/src/main/java/com/google/protobuf/InvalidProtocolBufferException.java \
java/src/main/java/com/google/protobuf/Message.java \
java/src/main/java/com/google/protobuf/RpcCallback.java \
java/src/main/java/com/google/protobuf/RpcChannel.java \
java/src/main/java/com/google/protobuf/RpcController.java \
java/src/main/java/com/google/protobuf/RpcUtil.java \
java/src/main/java/com/google/protobuf/Service.java \
java/src/main/java/com/google/protobuf/TextFormat.java \
java/src/main/java/com/google/protobuf/UninitializedMessageException.java \
java/src/main/java/com/google/protobuf/UnknownFieldSet.java \
java/src/main/java/com/google/protobuf/WireFormat.java \
java/src/test/java/com/google/protobuf/AbstractMessageTest.java \
java/src/test/java/com/google/protobuf/CodedInputStreamTest.java \
java/src/test/java/com/google/protobuf/CodedOutputStreamTest.java \
java/src/test/java/com/google/protobuf/DescriptorsTest.java \
java/src/test/java/com/google/protobuf/DynamicMessageTest.java \
java/src/test/java/com/google/protobuf/GeneratedMessageTest.java \
java/src/test/java/com/google/protobuf/MessageTest.java \
java/src/test/java/com/google/protobuf/ServiceTest.java \
java/src/test/java/com/google/protobuf/TestUtil.java \
java/src/test/java/com/google/protobuf/TextFormatTest.java \
java/src/test/java/com/google/protobuf/UnknownFieldSetTest.java \
java/src/test/java/com/google/protobuf/WireFormatTest.java \
java/src/test/java/com/google/protobuf/multiple_files_test.proto \
java/pom.xml \
java/README.txt \
python/google/protobuf/internal/generator_test.py \
python/google/protobuf/internal/decoder.py \
python/google/protobuf/internal/decoder_test.py \
python/google/protobuf/internal/descriptor_test.py \
python/google/protobuf/internal/encoder.py \
python/google/protobuf/internal/encoder_test.py \
python/google/protobuf/internal/input_stream.py \
python/google/protobuf/internal/input_stream_test.py \
python/google/protobuf/internal/message_listener.py \
python/google/protobuf/internal/more_extensions.proto \
python/google/protobuf/internal/more_messages.proto \
python/google/protobuf/internal/output_stream.py \
python/google/protobuf/internal/output_stream_test.py \
python/google/protobuf/internal/reflection_test.py \
python/google/protobuf/internal/service_reflection_test.py \
python/google/protobuf/internal/test_util.py \
python/google/protobuf/internal/text_format_test.py \
python/google/protobuf/internal/wire_format.py \
python/google/protobuf/internal/wire_format_test.py \
python/google/protobuf/internal/__init__.py \
python/google/protobuf/descriptor.py \
python/google/protobuf/message.py \
python/google/protobuf/reflection.py \
python/google/protobuf/service.py \
python/google/protobuf/service_reflection.py \
python/google/protobuf/text_format.py \
python/google/protobuf/__init__.py \
python/google/__init__.py \
python/ez_setup.py \
python/setup.py \
python/mox.py \
python/stubout.py \
python/README.txt
# Deletes all the files generated by autogen.sh.
MAINTAINERCLEANFILES = \
aclocal.m4 \
config.guess \
config.sub \
configure \
depcomp \
install-sh \
ltmain.sh \
Makefile.in \
missing \
mkinstalldirs \
config.h.in \
stamp.h.in

77
README.txt
View file

@ -1,77 +0,0 @@
Protocol Buffers - Google's data interchange format
Copyright 2008 Google Inc.
http://code.google.com/apis/protocolbuffers/
BETA WARNING
============
This package is a beta. This means that API may change in an
incompatible way in the future. It's unlikely that any big changes
will be made, but we can make no promises. Expect a non-beta release
sometime in August 2008.
C++ Installation - Unix
=======================
To build and install the C++ Protocol Buffer runtime and the Protocol
Buffer compiler (protoc) execute the following:
$ ./configure
$ make
$ make check
$ make install
If "make check" fails, you can still install, but it is likely that
some features of this library will not work correctly on your system.
Proceed at your own risk.
"make install" may require superuser privileges.
For advanced usage information on configure and make, see INSTALL.txt.
** Hint on insall location **
By default, the package will be installed to /usr/local. However,
on many platforms, /usr/local/lib is not part of LD_LIBRARY_PATH.
You can add it, but it may be easier to just install to /usr
instead. To do this, invoke configure as follows:
./configure --prefix=/usr
If you already built the package with a different prefix, make sure
to run "make clean" before building again.
** Note for Solaris users **
Solaris 10 x86 has a bug that will make linking fail, complaining
about libstdc++.la being invalid. We have included a work-around
in this package. To use the work-around, run configure as follows:
./configure LDFLAGS=-L$PWD/src/solaris
See src/solaris/libstdc++.la for more info on this bug.
C++ Installation - Windows
==========================
If you are using Micosoft Visual C++, see vsprojects/readme.txt.
If you are using Cygwin or MinGW, follow the Unix installation
instructions, above.
Java and Python Installation
============================
The Java and Python runtime libraries for Protocol Buffers are located
in the java and python directories. See the README file in each
directory for more information on how to compile and install them.
Note that both of them require you to first install the Protocol
Buffer compiler (protoc), which is part of the C++ package.
Usage
=====
The complete documentation for Protocol Buffers is available via the
web at:
http://code.google.com/apis/protocolbuffers/

27
autogen.sh
View file

@ -1,27 +0,0 @@
#!/bin/sh
# Run this script to generate the configure script and other files that will
# be included in the distribution. These files are not checked in because they
# are automatically generated.
# Check that we're being run from the right directory.
if test ! -e src/google/protobuf/stubs/common.h; then
cat >&2 << __EOF__
Could not find source code. Make sure you are running this script from the
root of the distribution tree.
__EOF__
exit 1
fi
set -ex
rm -rf autom4te.cache
aclocal-1.10 --force -I m4
libtoolize -c -f
autoheader -f -W all
automake-1.10 --foreign -a -c -f -W all
autoconf -f -W all,no-obsolete
rm -rf autom4te.cache config.h.in~
exit 0

39
configure.ac
View file

@ -1,39 +0,0 @@
## Process this file with autoconf to produce configure.
## In general, the safest way to proceed is to run ./autogen.sh
AC_PREREQ(2.59)
# Note: If you change the version, you must also update it in:
# * java/pom.xml
# * python/setup.py
# * src/google/protobuf/stubs/common.h
AC_INIT(protobuf, 2.0.1-SNAPSHOT, protobuf@googlegroups.com)
AC_CONFIG_SRCDIR(src/google/protobuf/message.cc)
AM_CONFIG_HEADER(config.h)
AM_INIT_AUTOMAKE
# Checks for programs.
AC_PROG_CC
AC_PROG_CXX
AC_PROG_LIBTOOL
AM_CONDITIONAL(GCC, test "$GCC" = yes) # let the Makefile know if we're gcc
# Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS([fcntl.h inttypes.h limits.h stdlib.h unistd.h])
if pkg-config --atleast-version=1.9 mono; then
with_mono=yes
fi
AM_CONDITIONAL(MONO, test x$with_mono = xyes)
# Checks for library functions.
AC_FUNC_MEMCMP
AC_FUNC_STRTOD
AC_CHECK_FUNCS([ftruncate memset mkdir strchr strerror strtol])
ACX_PTHREAD
AC_CXX_STL_HASH
AC_OUTPUT( Makefile src/Makefile csharp/Makefile )

BIN
csharp/Google.ProtocolBuffers.pub
View file

Binary file not shown.

66
csharp/Makefile.am
View file

@ -1,66 +0,0 @@
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = google-pb.pc
noinst_SCRIPTS = Google.ProtocolBuffers.dll
Google.ProtocolBuffers.dll_sources = \
$(srcdir)/ProtocolBuffers/AbstractBuilder.cs \
$(srcdir)/ProtocolBuffers/AbstractMessage.cs \
$(srcdir)/ProtocolBuffers/ByteString.cs \
$(srcdir)/ProtocolBuffers/CodedInputStream.cs \
$(srcdir)/ProtocolBuffers/CodedOutputStream.cs \
$(srcdir)/ProtocolBuffers/Collections/Dictionaries.cs \
$(srcdir)/ProtocolBuffers/Collections/Lists.cs \
$(srcdir)/ProtocolBuffers/Collections/ReadOnlyDictionary.cs \
$(srcdir)/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs \
$(srcdir)/ProtocolBuffers/DescriptorProtos/IDescriptorProto.cs \
$(srcdir)/ProtocolBuffers/DescriptorProtos/PartialClasses.cs \
$(srcdir)/ProtocolBuffers/Descriptors/DescriptorBase.cs \
$(srcdir)/ProtocolBuffers/Descriptors/DescriptorPool.cs \
$(srcdir)/ProtocolBuffers/Descriptors/DescriptorUtil.cs \
$(srcdir)/ProtocolBuffers/Descriptors/DescriptorValidationException.cs \
$(srcdir)/ProtocolBuffers/Descriptors/EnumDescriptor.cs \
$(srcdir)/ProtocolBuffers/Descriptors/EnumDescriptorIndexAttribute.cs \
$(srcdir)/ProtocolBuffers/Descriptors/EnumValueDescriptor.cs \
$(srcdir)/ProtocolBuffers/Descriptors/FieldDescriptor.cs \
$(srcdir)/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs \
$(srcdir)/ProtocolBuffers/Descriptors/FieldType.cs \
$(srcdir)/ProtocolBuffers/Descriptors/FileDescriptor.cs \
$(srcdir)/ProtocolBuffers/Descriptors/IndexedDescriptorBase.cs \
$(srcdir)/ProtocolBuffers/Descriptors/MappedType.cs \
$(srcdir)/ProtocolBuffers/Descriptors/MethodDescriptor.cs \
$(srcdir)/ProtocolBuffers/Descriptors/MessageDescriptor.cs \
$(srcdir)/ProtocolBuffers/Descriptors/PackageDescriptor.cs \
$(srcdir)/ProtocolBuffers/Descriptors/ServiceDescriptor.cs \
$(srcdir)/ProtocolBuffers/ExtensionInfo.cs \
$(srcdir)/ProtocolBuffers/ExtensionRegistry.cs \
$(srcdir)/ProtocolBuffers/FieldAccess/Delegates.cs \
$(srcdir)/ProtocolBuffers/FieldAccess/FieldAccessorTable.cs \
$(srcdir)/ProtocolBuffers/FieldAccess/IFieldAccessor.cs \
$(srcdir)/ProtocolBuffers/FieldSet.cs \
$(srcdir)/ProtocolBuffers/GeneratedBuilder.cs \
$(srcdir)/ProtocolBuffers/GeneratedExtension.cs \
$(srcdir)/ProtocolBuffers/GeneratedMessage.cs \
$(srcdir)/ProtocolBuffers/IBuilder.cs \
$(srcdir)/ProtocolBuffers/IMessage.cs \
$(srcdir)/ProtocolBuffers/InvalidProtocolBufferException.cs \
$(srcdir)/ProtocolBuffers/Properties/AssemblyInfo.cs \
$(srcdir)/ProtocolBuffers/TextFormat.cs \
$(srcdir)/ProtocolBuffers/UninitializedMessageException.cs \
$(srcdir)/ProtocolBuffers/UnknownField.cs \
$(srcdir)/ProtocolBuffers/UnknownFieldSet.cs \
$(srcdir)/ProtocolBuffers/WireFormat.cs
Google.ProtocolBuffers.dll: $(Google.ProtocolBuffers.dll_sources)
cp $(srcdir)/ProtocolBuffers/Properties/Google.ProtocolBuffers.snk .
gmcs -codepage:utf8 -debug -target:library -out:Google.ProtocolBuffers.dll \
$(Google.ProtocolBuffers.dll_sources) -keyfile:Google.ProtocolBuffers.snk
install-data-local: Google.ProtocolBuffers.dll
gacutil -i Google.ProtocolBuffers.dll -package google
EXTRA_DIST = $(Google.ProtocolBuffers.dll_sources) google-pb.pc.in
google-pb.pc: Makefile.am google-pb.pc.in
sed "s,@PREFIX@,${prefix}," < $(srcdir)/google-pb.pc.in > google-pb.pc

95
csharp/ProtoGen.Test/DependencyResolutionTest.cs
View file

@ -1,95 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
using NUnit.Framework;
using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.ProtoGen;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// Tests for the dependency resolution in Generator.
/// </summary>
[TestFixture]
public class DependencyResolutionTest {
[Test]
public void TwoDistinctFiles() {
FileDescriptorProto first = new FileDescriptorProto.Builder { Name="First" }.Build();
FileDescriptorProto second = new FileDescriptorProto.Builder { Name="Second" }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
Assert.AreEqual(2, converted.Count);
Assert.AreEqual("First", converted[0].Name);
Assert.AreEqual(0, converted[0].Dependencies.Count);
Assert.AreEqual("Second", converted[1].Name);
Assert.AreEqual(0, converted[1].Dependencies.Count);
}
[Test]
public void FirstDependsOnSecond() {
FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = {"Second"} }.Build();
FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second" }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
Assert.AreEqual(2, converted.Count);
Assert.AreEqual("First", converted[0].Name);
Assert.AreEqual(1, converted[0].Dependencies.Count);
Assert.AreEqual(converted[1], converted[0].Dependencies[0]);
Assert.AreEqual("Second", converted[1].Name);
Assert.AreEqual(0, converted[1].Dependencies.Count);
}
[Test]
public void SecondDependsOnFirst() {
FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First" }.Build();
FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = {"First"} }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
Assert.AreEqual(2, converted.Count);
Assert.AreEqual("First", converted[0].Name);
Assert.AreEqual(0, converted[0].Dependencies.Count);
Assert.AreEqual("Second", converted[1].Name);
Assert.AreEqual(1, converted[1].Dependencies.Count);
Assert.AreEqual(converted[0], converted[1].Dependencies[0]);
}
[Test]
public void CircularDependency() {
FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "Second" } }.Build();
FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = { "First" } }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
try {
Generator.ConvertDescriptors(set);
Assert.Fail("Expected exception");
} catch (DependencyResolutionException) {
// Expected
}
}
[Test]
public void MissingDependency() {
FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "Second" } }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first } };
try {
Generator.ConvertDescriptors(set);
Assert.Fail("Expected exception");
} catch (DependencyResolutionException) {
// Expected
}
}
[Test]
public void SelfDependency() {
FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "First" } }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first } };
try {
Generator.ConvertDescriptors(set);
Assert.Fail("Expected exception");
} catch (DependencyResolutionException) {
// Expected
}
}
}
}

69
csharp/ProtoGen.Test/DescriptorUtilTest.cs
View file

@ -1,69 +0,0 @@
using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.Descriptors;
using NUnit.Framework;
namespace Google.ProtocolBuffers.ProtoGen {
[TestFixture]
public class DescriptorUtilTest {
[Test]
public void ExplicitNamespace() {
FileDescriptorProto proto = new FileDescriptorProto.Builder {
Name = "x", Package = "pack", Options = new FileOptions.Builder().SetExtension(CSharpOptions.CSharpNamespace, "Foo.Bar").Build()
}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("Foo.Bar", DescriptorUtil.GetNamespace(descriptor));
}
[Test]
public void NoNamespaceFallsBackToPackage() {
FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "x", Package = "pack" }.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("pack", DescriptorUtil.GetNamespace(descriptor));
}
[Test]
public void NoNamespaceOrPackageFallsBackToEmptyString() {
FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "x" }.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("", DescriptorUtil.GetNamespace(descriptor));
}
[Test]
public void ExplicitlyNamedFileClass() {
FileDescriptorProto proto = new FileDescriptorProto.Builder {
Name = "x", Options = new FileOptions.Builder().SetExtension(CSharpOptions.CSharpUmbrellaClassname, "Foo").Build()
}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("Foo", DescriptorUtil.GetUmbrellaClassName(descriptor));
}
[Test]
public void ImplicitFileClassWithProtoSuffix() {
FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "foo_bar.proto" }.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor));
}
[Test]
public void ImplicitFileClassWithProtoDevelSuffix() {
FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "foo_bar.protodevel" }.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor));
}
[Test]
public void ImplicitFileClassWithNoSuffix() {
FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "foo_bar" }.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor));
}
[Test]
public void ImplicitFileClassWithDirectoryStructure() {
FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "x/y/foo_bar" }.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor));
}
}
}

10
csharp/ProtoGen.Test/GeneratorTest.cs
View file

@ -1,10 +0,0 @@
using Google.ProtocolBuffers.DescriptorProtos;
using NUnit.Framework;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
[TestFixture]
public class GeneratorTest {
}
}

33
csharp/ProtoGen.Test/HelpersTest.cs
View file

@ -1,33 +0,0 @@
using Google.ProtocolBuffers.ProtoGen;
using NUnit.Framework;
namespace Google.ProtocolBuffers.ProtoGen {
[TestFixture]
public class HelpersTest {
[Test]
public void UnderscoresToPascalCase() {
Assert.AreEqual("FooBar", Helpers.UnderscoresToPascalCase("Foo_bar"));
Assert.AreEqual("FooBar", Helpers.UnderscoresToPascalCase("foo_bar"));
Assert.AreEqual("Foo0Bar", Helpers.UnderscoresToPascalCase("Foo0bar"));
Assert.AreEqual("FooBar", Helpers.UnderscoresToPascalCase("Foo_+_Bar"));
}
[Test]
public void UnderscoresToCamelCase() {
Assert.AreEqual("fooBar", Helpers.UnderscoresToCamelCase("Foo_bar"));
Assert.AreEqual("fooBar", Helpers.UnderscoresToCamelCase("foo_bar"));
Assert.AreEqual("foo0Bar", Helpers.UnderscoresToCamelCase("Foo0bar"));
Assert.AreEqual("fooBar", Helpers.UnderscoresToCamelCase("Foo_+_Bar"));
}
[Test]
public void StripSuffix() {
string text = "FooBar";
Assert.IsFalse(Helpers.StripSuffix(ref text, "Foo"));
Assert.AreEqual("FooBar", text);
Assert.IsTrue(Helpers.StripSuffix(ref text, "Bar"));
Assert.AreEqual("Foo", text);
}
}
}

36
csharp/ProtoGen.Test/Properties/AssemblyInfo.cs
View file

@ -1,36 +0,0 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ProtoGen.Test")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ProtoGen.Test")]
[assembly: AssemblyCopyright("Copyright © 2008")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("40720ee3-2d15-4271-8c42-8f9cfd01b52f")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

BIN
csharp/ProtoGen.Test/Properties/Google.ProtocolBuffers.ProtoGen.Test.snk
View file

Binary file not shown.

76
csharp/ProtoGen.Test/ProtoGen.Test.csproj
View file

@ -1,76 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{C268DA4C-4004-47DA-AF23-44C983281A68}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Google.ProtocolBuffers.ProtoGen</RootNamespace>
<AssemblyName>Google.ProtocolBuffers.ProtoGen.Test</AssemblyName>
<TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>Properties\Google.ProtocolBuffers.ProtoGen.Test.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="nunit.framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77">
<SpecificVersion>False</SpecificVersion>
<HintPath>..\lib\nunit.framework.dll</HintPath>
</Reference>
<Reference Include="Rhino.Mocks, Version=3.5.0.2, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
<SpecificVersion>False</SpecificVersion>
<HintPath>..\lib\Rhino.Mocks.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="DependencyResolutionTest.cs" />
<Compile Include="DescriptorUtilTest.cs" />
<Compile Include="GeneratorTest.cs" />
<Compile Include="HelpersTest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj">
<Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project>
<Name>ProtocolBuffers</Name>
</ProjectReference>
<ProjectReference Include="..\ProtoGen\ProtoGen.csproj">
<Project>{250ADE34-82FD-4BAE-86D5-985FBE589C4A}</Project>
<Name>ProtoGen</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<None Include="Properties\Google.ProtocolBuffers.ProtoGen.Test.snk" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

17
csharp/ProtoGen/DependencyResolutionException.cs
View file

@ -1,17 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// Exception thrown when dependencies within a descriptor set can't be resolved.
/// </summary>
public sealed class DependencyResolutionException : Exception {
public DependencyResolutionException(string message) : base(message) {
}
public DependencyResolutionException(string format, params object[] args)
: base(string.Format(format, args)) {
}
}
}

108
csharp/ProtoGen/DescriptorUtil.cs
View file

@ -1,108 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// Utility class for determining namespaces etc.
/// </summary>
internal static class DescriptorUtil {
internal static bool NestClasses(IDescriptor descriptor) {
// Defaults to false
return descriptor.File.Options.GetExtension(CSharpOptions.CSharpNestClasses);
}
internal static string GetNamespace(FileDescriptor descriptor) {
if (descriptor.Name == "google/protobuf/descriptor.proto") {
return typeof(DescriptorProtoFile).Namespace;
}
return descriptor.Options.HasExtension(CSharpOptions.CSharpNamespace) ?
descriptor.Options.GetExtension(CSharpOptions.CSharpNamespace) : descriptor.Package;
}
// Groups are hacky: The name of the field is just the lower-cased name
// of the group type. In C#, though, we would like to retain the original
// capitalization of the type name.
internal static string GetFieldName(FieldDescriptor descriptor) {
if (descriptor.FieldType == FieldType.Group) {
return descriptor.MessageType.Name;
} else {
return descriptor.Name;
}
}
internal static string GetClassName(IDescriptor descriptor) {
return ToCSharpName(descriptor.FullName, descriptor.File);
}
internal static string GetFullUmbrellaClassName(FileDescriptor descriptor) {
string result = GetNamespace(descriptor);
if (result != "") result += '.';
result += GetUmbrellaClassName(descriptor);
return "global::" + result;
}
internal static string GetUmbrellaClassName(FileDescriptor descriptor) {
if (descriptor.Name == "google/protobuf/descriptor.proto") {
return typeof(DescriptorProtoFile).Name;
}
FileOptions options = descriptor.Options;
if (options.HasExtension(CSharpOptions.CSharpUmbrellaClassname)) {
return descriptor.Options.GetExtension(CSharpOptions.CSharpUmbrellaClassname);
}
int lastSlash = descriptor.Name.LastIndexOf('/');
string baseName = descriptor.Name.Substring(lastSlash + 1);
return Helpers.UnderscoresToPascalCase(StripProto(baseName));
}
private static string StripProto(string text) {
if (!Helpers.StripSuffix(ref text, ".protodevel")) {
Helpers.StripSuffix(ref text, ".proto");
}
return text;
}
private static string ToCSharpName(string name, FileDescriptor file) {
string result;
if (!NestClasses(file)) {
result = GetNamespace(file);
} else {
result = GetUmbrellaClassName(file);
}
if (result != "") {
result += '.';
}
string classname;
if (file.Package == "") {
classname = name;
} else {
// Strip the proto package from full_name since we've replaced it with
// the C# namespace.
classname = name.Substring(file.Package.Length + 1);
}
result += classname.Replace(".", ".Types.");
return "global::" + result;
}
internal static string GetMappedTypeName(MappedType type) {
switch(type) {
case MappedType.Int32: return "int";
case MappedType.Int64: return "long";
case MappedType.UInt32: return "uint";
case MappedType.UInt64: return "ulong";
case MappedType.Single: return "float";
case MappedType.Double: return "double";
case MappedType.Boolean: return "bool";
case MappedType.String: return "string";
case MappedType.ByteString: return "pb::ByteString";
case MappedType.Enum: return null;
case MappedType.Message: return null;
default:
throw new ArgumentOutOfRangeException("Unknown mapped type " + type);
}
}
}
}

75
csharp/ProtoGen/EnumFieldGenerator.cs
View file

@ -1,75 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal class EnumFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
internal EnumFieldGenerator(FieldDescriptor descriptor)
: base(descriptor) {
}
public void GenerateMembers(TextGenerator writer) {
writer.WriteLine("private bool has{0};", CapitalizedName);
writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue);
writer.WriteLine("public bool Has{0} {{", CapitalizedName);
writer.WriteLine(" get {{ return has{0}; }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return {0}_; }}", Name);
writer.WriteLine("}");
}
public void GenerateBuilderMembers(TextGenerator writer) {
writer.WriteLine("public bool Has{0} {{", CapitalizedName);
writer.WriteLine(" get {{ return result.Has{0}; }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return result.{0}; }}", PropertyName);
writer.WriteLine(" set {{ Set{0}(value); }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}({1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.has{0} = true;", CapitalizedName);
writer.WriteLine(" result.{0}_ = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
writer.WriteLine(" result.has{0} = false;", CapitalizedName);
writer.WriteLine(" result.{0}_ = {1};", Name, DefaultValue);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateMergingCode(TextGenerator writer) {
writer.WriteLine("if (other.Has{0}) {{", CapitalizedName);
writer.WriteLine(" {0} = other.{0};", PropertyName);
writer.WriteLine("}");
}
public void GenerateBuildingCode(TextGenerator writer) {
// Nothing to do here for enum types
}
public void GenerateParsingCode(TextGenerator writer) {
// TODO(jonskeet): Make a more efficient way of doing this
writer.WriteLine("int rawValue = input.ReadEnum();");
writer.WriteLine("if (!global::System.Enum.IsDefined(typeof({0}), rawValue)) {{", TypeName);
writer.WriteLine(" unknownFields.MergeVarintField({0}, (ulong) rawValue);", Number);
writer.WriteLine("} else {");
writer.WriteLine(" {0} = ({1}) rawValue;", PropertyName, TypeName);
writer.WriteLine("}");
}
public void GenerateSerializationCode(TextGenerator writer) {
writer.WriteLine("if (Has{0}) {{", CapitalizedName);
writer.WriteLine(" output.WriteEnum({0}, (int) {1});", Number, PropertyName);
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer) {
writer.WriteLine("if (Has{0}) {{", CapitalizedName);
writer.WriteLine(" size += pb::CodedOutputStream.ComputeEnumSize({0}, (int) {1});", Number, PropertyName);
writer.WriteLine("}");
}
}
}

19
csharp/ProtoGen/EnumGenerator.cs
View file

@ -1,19 +0,0 @@
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal class EnumGenerator : SourceGeneratorBase<EnumDescriptor>, ISourceGenerator {
internal EnumGenerator(EnumDescriptor descriptor) : base(descriptor) {
}
public void Generate(TextGenerator writer) {
writer.WriteLine("{0} enum {1} {{", ClassAccessLevel, Descriptor.Name);
writer.Indent();
foreach (EnumValueDescriptor value in Descriptor.Values) {
writer.WriteLine("{0} = {1},", value.Name, value.Number);
}
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
}
}

37
csharp/ProtoGen/ExtensionGenerator.cs
View file

@ -1,37 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal class ExtensionGenerator : SourceGeneratorBase<FieldDescriptor>, ISourceGenerator {
internal ExtensionGenerator(FieldDescriptor descriptor) : base(descriptor) {
}
public void Generate(TextGenerator writer) {
string name = Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(Descriptor));
string type;
switch (Descriptor.MappedType) {
case MappedType.Message:
type = DescriptorUtil.GetClassName(Descriptor.MessageType);
break;
case MappedType.Enum:
type = DescriptorUtil.GetClassName(Descriptor.EnumType);
break;
default:
type = DescriptorUtil.GetMappedTypeName(Descriptor.MappedType);
break;
}
if (Descriptor.IsRepeated) {
writer.WriteLine("{0} static readonly", ClassAccessLevel);
writer.WriteLine(" pb::GeneratedExtensionBase<scg::IList<{0}>> {1} =", type, name);
writer.WriteLine(" pb::GeneratedRepeatExtension<{0}>.CreateInstance(Descriptor.Extensions[{1}]);", type, Descriptor.Index);
} else {
writer.WriteLine("{0} static readonly pb::GeneratedExtensionBase<{1}> {2} =", ClassAccessLevel, type, name);
writer.WriteLine(" pb::GeneratedSingleExtension<{0}>.CreateInstance(Descriptor.Extensions[{1}]);", type, Descriptor.Index);
}
}
}
}

130
csharp/ProtoGen/FieldGeneratorBase.cs
View file

@ -1,130 +0,0 @@
using System;
using Google.ProtocolBuffers.Descriptors;
using System.Globalization;
namespace Google.ProtocolBuffers.ProtoGen {
internal abstract class FieldGeneratorBase : SourceGeneratorBase<FieldDescriptor> {
protected FieldGeneratorBase(FieldDescriptor descriptor)
: base(descriptor) {
}
private static bool AllPrintableAscii(string text) {
foreach (char c in text) {
if (c < 0x20 || c > 0x7e) {
return false;
}
}
return true;
}
protected string DefaultValue {
get {
string suffix = "";
switch (Descriptor.FieldType) {
case FieldType.Float: suffix = "F"; break;
case FieldType.Double: suffix = "D"; break;
case FieldType.Int64: suffix = "L"; break;
case FieldType.UInt64: suffix = "UL"; break;
}
switch (Descriptor.FieldType) {
case FieldType.Float:
case FieldType.Double:
case FieldType.Int32:
case FieldType.Int64:
case FieldType.SInt32:
case FieldType.SInt64:
case FieldType.SFixed32:
case FieldType.SFixed64:
case FieldType.UInt32:
case FieldType.UInt64:
case FieldType.Fixed32:
case FieldType.Fixed64:
// The simple Object.ToString converts using the current culture.
// We want to always use the invariant culture so it's predictable.
IConvertible value = (IConvertible) Descriptor.DefaultValue;
return value.ToString(CultureInfo.InvariantCulture) + suffix;
case FieldType.Bool:
return (bool) Descriptor.DefaultValue ? "true" : "false";
case FieldType.Bytes:
if (!Descriptor.HasDefaultValue) {
return "pb::ByteString.Empty";
}
return string.Format("(pb::ByteString) {0}.Descriptor.Fields[{1}].DefaultValue", TypeName, Number);
case FieldType.String:
if (AllPrintableAscii(Descriptor.Proto.DefaultValue)) {
// All chars are ASCII and printable. In this case we only
// need to escape quotes and backslashes.
return "\"" + Descriptor.Proto.DefaultValue
.Replace("\\", "\\\\")
.Replace("'", "\\'")
.Replace("\"", "\\\"")
+ "\"";
}
return string.Format("(string) {0}.Descriptor.Fields[{1}].DefaultValue", TypeName, Number);
case FieldType.Enum:
return TypeName + "." + ((EnumValueDescriptor) Descriptor.DefaultValue).Name;
case FieldType.Message:
case FieldType.Group:
return TypeName + ".DefaultInstance";
default:
throw new InvalidOperationException("Invalid field descriptor type");
}
}
}
/// <summary>
/// Usually the same as CapitalizedName, except when the enclosing type has the same name,
/// in which case an underscore is appended.
/// </summary>
protected string PropertyName {
get {
string ret = CapitalizedName;
if (ret == Descriptor.ContainingType.Name) {
ret += "_";
}
return ret;
}
}
protected string CapitalizedName {
get { return Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(Descriptor)); }
}
protected string Name {
get { return Helpers.UnderscoresToCamelCase(DescriptorUtil.GetFieldName(Descriptor)); }
}
protected int Number {
get { return Descriptor.FieldNumber; }
}
protected string TypeName {
get {
switch (Descriptor.FieldType) {
case FieldType.Enum:
return DescriptorUtil.GetClassName(Descriptor.EnumType);
case FieldType.Message:
case FieldType.Group:
return DescriptorUtil.GetClassName(Descriptor.MessageType);
default:
return DescriptorUtil.GetMappedTypeName(Descriptor.MappedType);
}
}
}
protected string MessageOrGroup {
get { return Descriptor.FieldType == FieldType.Group ? "Group" : "Message"; }
}
/// <summary>
/// Returns the type name as used in CodedInputStream method names: SFixed32, UInt32 etc.
/// </summary>
protected string CapitalizedTypeName {
get {
// Our enum names match perfectly. How serendipitous.
return Descriptor.FieldType.ToString();
}
}
}
}

138
csharp/ProtoGen/Generator.cs
View file

@ -1,138 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.DescriptorProtos;
using System.IO;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.Collections;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// Code generator for protocol buffers. Only C# is supported at the moment.
/// </summary>
public sealed class Generator {
readonly GeneratorOptions options;
private Generator(GeneratorOptions options) {
options.Validate();
this.options = options;
}
/// <summary>
/// Returns a generator configured with the specified options.
/// </summary>
public static Generator CreateGenerator(GeneratorOptions options) {
return new Generator(options);
}
public void Generate() {
foreach (string inputFile in options.InputFiles) {
FileDescriptorSet descriptorProtos;
ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
extensionRegistry.Add(CSharpOptions.CSharpUmbrellaClassname);
extensionRegistry.Add(CSharpOptions.CSharpMultipleFiles);
extensionRegistry.Add(CSharpOptions.CSharpNamespace);
extensionRegistry.Add(CSharpOptions.CSharpNestClasses);
extensionRegistry.Add(CSharpOptions.CSharpPublicClasses);
using (Stream inputStream = File.OpenRead(inputFile)) {
descriptorProtos = FileDescriptorSet.ParseFrom(inputStream, extensionRegistry);
}
IList<FileDescriptor> descriptors = ConvertDescriptors(descriptorProtos);
foreach (FileDescriptor descriptor in descriptors) {
Generate(descriptor);
}
}
}
/// <summary>
/// Generates code for a particular file. All dependencies must
/// already have been resolved.
/// </summary>
private void Generate(FileDescriptor descriptor) {
string umbrellaClass = DescriptorUtil.GetUmbrellaClassName(descriptor);
string ns = DescriptorUtil.GetNamespace(descriptor);
using (TextWriter textWriter = File.CreateText(Path.Combine(options.OutputDirectory, umbrellaClass + ".cs"))) {
TextGenerator writer = new TextGenerator(textWriter);
UmbrellaClassGenerator ucg = new UmbrellaClassGenerator(descriptor);
ucg.Generate(writer);
/*
GenerateSiblings(umbrellaSource, descriptor, descriptor.MessageTypes);
GenerateSiblings(umbrellaSource, descriptor, descriptor.EnumTypes);
GenerateSiblings(umbrellaSource, descriptor, descriptor.Services);*/
}
}
private static void GenerateSiblings<T>(SourceFileGenerator parentSourceGenerator, FileDescriptor file, IEnumerable<T> siblings)
where T : IDescriptor {
}
/// <summary>
/// Resolves any dependencies and converts FileDescriptorProtos into FileDescriptors.
/// The list returned is in the same order as the protos are listed in the descriptor set.
/// Note: this method is internal rather than private to allow testing.
/// </summary>
/// <exception cref="DependencyResolutionException">Not all dependencies could be resolved.</exception>
internal static IList<FileDescriptor> ConvertDescriptors(FileDescriptorSet descriptorProtos) {
// Simple strategy: Keep going through the list of protos to convert, only doing ones where
// we've already converted all the dependencies, until we get to a stalemate
IList<FileDescriptorProto> fileList = descriptorProtos.FileList;
FileDescriptor[] converted = new FileDescriptor[fileList.Count];
Dictionary<string, FileDescriptor> convertedMap = new Dictionary<string, FileDescriptor>();
int totalConverted = 0;
bool madeProgress = true;
while (madeProgress && totalConverted < converted.Length) {
madeProgress = false;
for (int i = 0; i < converted.Length; i++) {
if (converted[i] != null) {
// Already done this one
continue;
}
FileDescriptorProto candidate = fileList[i];
FileDescriptor[] dependencies = new FileDescriptor[candidate.DependencyList.Count];
bool foundAllDependencies = true;
for (int j = 0; j < dependencies.Length; j++) {
if (!convertedMap.TryGetValue(candidate.DependencyList[j], out dependencies[j])) {
foundAllDependencies = false;
break;
}
}
if (!foundAllDependencies) {
continue;
}
madeProgress = true;
totalConverted++;
converted[i] = FileDescriptor.BuildFrom(candidate, dependencies);
convertedMap[candidate.Name] = converted[i];
}
}
if (!madeProgress) {
StringBuilder remaining = new StringBuilder();
for (int i = 0; i < converted.Length; i++) {
if (converted[i] == null) {
if (remaining.Length != 0) {
remaining.Append(", ");
}
FileDescriptorProto failure = fileList[i];
remaining.Append(failure.Name);
remaining.Append(":");
foreach (string dependency in failure.DependencyList) {
if (!convertedMap.ContainsKey(dependency)) {
remaining.Append(" ");
remaining.Append(dependency);
}
}
remaining.Append(";");
}
}
throw new DependencyResolutionException("Unable to resolve all dependencies: " + remaining);
}
return Lists.AsReadOnly(converted);
}
}
}

69
csharp/ProtoGen/GeneratorOptions.cs
View file

@ -1,69 +0,0 @@
using System.Collections.Generic;
using System.IO;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// All the configuration required for the generator - where to generate
/// output files, the location of input files etc. While this isn't immutable
/// in practice, the contents shouldn't be changed after being passed to
/// the generator.
/// </summary>
public sealed class GeneratorOptions {
public string OutputDirectory { get; set; }
public IList<string> InputFiles { get; set; }
/// <summary>
/// Attempts to validate the options, but doesn't throw an exception if they're invalid.
/// Instead, when this method returns false, the output variable will contain a collection
/// of reasons for the validation failure.
/// </summary>
/// <param name="reasons">Variable to receive a list of reasons in case of validation failure.</param>
/// <returns>true if the options are valid; false otherwise</returns>
public bool TryValidate(out IList<string> reasons) {
List<string> tmpReasons = new List<string>();
// Output directory validation
if (string.IsNullOrEmpty(OutputDirectory)) {
tmpReasons.Add("No output directory specified");
} else {
if (!Directory.Exists(OutputDirectory)) {
tmpReasons.Add("Specified output directory (" + OutputDirectory + " doesn't exist.");
}
}
// Input file validation (just in terms of presence)
if (InputFiles == null || InputFiles.Count == 0) {
tmpReasons.Add("No input files specified");
} else {
foreach (string input in InputFiles) {
FileInfo fi = new FileInfo(input);
if (!fi.Exists) {
tmpReasons.Add("Input file " + input + " doesn't exist.");
}
}
}
if (tmpReasons.Count != 0) {
reasons = tmpReasons;
return false;
}
reasons = null;
return true;
}
/// <summary>
/// Validates that all the options have been set and are valid,
/// throwing an exception if they haven't.
/// </summary>
/// <exception cref="InvalidOptionsException">The options are invalid.</exception>
public void Validate() {
IList<string> reasons;
if (!TryValidate(out reasons)) {
throw new InvalidOptionsException(reasons);
}
}
}
}

78
csharp/ProtoGen/Helpers.cs
View file

@ -1,78 +0,0 @@
using System;
using System.Text;
using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// Helpers to resolve class names etc.
/// </summary>
internal static class Helpers {
internal static string UnderscoresToPascalCase(string input) {
return UnderscoresToPascalOrCamelCase(input, true);
}
internal static string UnderscoresToCamelCase(string input) {
return UnderscoresToPascalOrCamelCase(input, false);
}
internal static void WriteNamespaces(TextGenerator writer) {
writer.WriteLine("using pb = global::Google.ProtocolBuffers;");
writer.WriteLine("using pbc = global::Google.ProtocolBuffers.Collections;");
writer.WriteLine("using pbd = global::Google.ProtocolBuffers.Descriptors;");
writer.WriteLine("using scg = global::System.Collections.Generic;");
}
/// <summary>
/// Converts a string to Pascal or Camel case. The first letter is capitalized or
/// lower-cased depending on <paramref name="pascal"/> is true.
/// After the first letter, any punctuation is removed but triggers capitalization
/// of the next letter. Digits are preserved but trigger capitalization of the next
/// letter.
/// All capitalisation is done in the invariant culture.
/// </summary>
private static string UnderscoresToPascalOrCamelCase(string input, bool pascal) {
StringBuilder result = new StringBuilder();
bool capitaliseNext = pascal;
for (int i=0; i < input.Length; i++) {
char c = input[i];
if ('a' <= c && c <= 'z') {
if (capitaliseNext) {
result.Append(char.ToUpperInvariant(c));
} else {
result.Append(c);
}
capitaliseNext = false;
} else if ('A' <= c && c <= 'Z') {
if (i == 0 && !pascal) {
// Force first letter to lower-case unless explicitly told to
// capitalize it.
result.Append(char.ToLowerInvariant(c));
} else {
// Capital letters after the first are left as-is.
result.Append(c);
}
capitaliseNext = false;
} else if ('0' <= c && c <= '9') {
result.Append(c);
capitaliseNext = true;
} else {
capitaliseNext = true;
}
}
return result.ToString();
}
/// <summary>
/// Attempts to strip a suffix from a string, returning whether
/// or not the suffix was actually present.
/// </summary>
internal static bool StripSuffix(ref string text, string suffix) {
if (text.EndsWith(suffix)) {
text = text.Substring(0, text.Length - suffix.Length);
return true;
}
return false;
}
}
}

11
csharp/ProtoGen/IFieldSourceGenerator.cs
View file

@ -1,11 +0,0 @@
namespace Google.ProtocolBuffers.ProtoGen {
internal interface IFieldSourceGenerator {
void GenerateMembers(TextGenerator writer);
void GenerateBuilderMembers(TextGenerator writer);
void GenerateMergingCode(TextGenerator writer);
void GenerateBuildingCode(TextGenerator writer);
void GenerateParsingCode(TextGenerator writer);
void GenerateSerializationCode(TextGenerator writer);
void GenerateSerializedSizeCode(TextGenerator writer);
}
}

5
csharp/ProtoGen/ISourceGenerator.cs
View file

@ -1,5 +0,0 @@
namespace Google.ProtocolBuffers.ProtoGen {
internal interface ISourceGenerator {
void Generate(TextGenerator writer);
}
}

36
csharp/ProtoGen/InvalidOptionsException.cs
View file

@ -1,36 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.Collections;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// Exception thrown to indicate that the options passed were invalid.
/// </summary>
public sealed class InvalidOptionsException : Exception {
private readonly IList<string> reasons;
/// <summary>
/// An immutable list of reasons why the options were invalid.
/// </summary>
public IList<string> Reasons {
get { return reasons; }
}
public InvalidOptionsException(IList<string> reasons)
: base(BuildMessage(reasons)) {
this.reasons = Lists.AsReadOnly(reasons);
}
private static string BuildMessage(IEnumerable<string> reasons) {
StringBuilder builder = new StringBuilder("Invalid options:");
builder.AppendLine();
foreach (string reason in reasons) {
builder.Append(" ");
builder.AppendLine(reason);
}
return builder.ToString();
}
}
}

92
csharp/ProtoGen/MessageFieldGenerator.cs
View file

@ -1,92 +0,0 @@
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal class MessageFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
internal MessageFieldGenerator(FieldDescriptor descriptor)
: base(descriptor) {
}
public void GenerateMembers(TextGenerator writer) {
writer.WriteLine("private bool has{0};", CapitalizedName);
writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue);
writer.WriteLine("public bool Has{0} {{", CapitalizedName);
writer.WriteLine(" get {{ return has{0}; }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public {0} {1} {{", TypeName, CapitalizedName);
writer.WriteLine(" get {{ return {0}_; }}", Name);
writer.WriteLine("}");
}
public void GenerateBuilderMembers(TextGenerator writer) {
writer.WriteLine("public bool Has{0} {{", CapitalizedName);
writer.WriteLine(" get {{ return result.Has{0}; }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public {0} {1} {{", TypeName, CapitalizedName);
writer.WriteLine(" get {{ return result.{0}; }}", CapitalizedName);
writer.WriteLine(" set {{ Set{0}(value); }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}({1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.has{0} = true;", CapitalizedName);
writer.WriteLine(" result.{0}_ = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}({1}.Builder builderForValue) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.has{0} = true;", CapitalizedName);
writer.WriteLine(" result.{0}_ = builderForValue.Build();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Merge{0}({1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" if (result.Has{0} &&", CapitalizedName);
writer.WriteLine(" result.{0}_ != {1}) {{", Name, DefaultValue);
writer.WriteLine(" result.{0}_ = {1}.CreateBuilder(result.{0}_).MergeFrom(value).BuildPartial();", Name, TypeName);
writer.WriteLine(" } else {");
writer.WriteLine(" result.{0}_ = value;", Name);
writer.WriteLine(" }");
writer.WriteLine(" result.has{0} = true;", CapitalizedName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
writer.WriteLine(" result.has{0} = false;", CapitalizedName);
writer.WriteLine(" result.{0}_ = {1};", Name, DefaultValue);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateMergingCode(TextGenerator writer) {
writer.WriteLine("if (other.Has{0}) {{", CapitalizedName);
writer.WriteLine(" Merge{0}(other.{0});", CapitalizedName);
writer.WriteLine("}");
}
public void GenerateBuildingCode(TextGenerator writer) {
// Nothing to do for singular fields
}
public void GenerateParsingCode(TextGenerator writer) {
writer.WriteLine("{0}.Builder subBuilder = {0}.CreateBuilder();", TypeName);
writer.WriteLine("if (Has{0}) {{", CapitalizedName);
writer.WriteLine(" subBuilder.MergeFrom({0});", CapitalizedName);
writer.WriteLine("}");
if (Descriptor.FieldType == FieldType.Group) {
writer.WriteLine("input.ReadGroup({0}, subBuilder, extensionRegistry);", Number);
} else {
writer.WriteLine("input.ReadMessage(subBuilder, extensionRegistry);");
}
writer.WriteLine("{0} = subBuilder.BuildPartial();", CapitalizedName);
}
public void GenerateSerializationCode(TextGenerator writer) {
writer.WriteLine("if (Has{0}) {{", CapitalizedName);
writer.WriteLine(" output.Write{0}({1}, {2});", MessageOrGroup, Number, CapitalizedName);
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer) {
writer.WriteLine("if (Has{0}) {{", CapitalizedName);
writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, {2});",
MessageOrGroup, Number, CapitalizedName);
writer.WriteLine("}");
}
}
}

453
csharp/ProtoGen/MessageGenerator.cs
View file

@ -1,453 +0,0 @@
using System.Collections;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.DescriptorProtos;
using System.Collections.Generic;
using ExtensionRange = Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange;
namespace Google.ProtocolBuffers.ProtoGen {
internal class MessageGenerator : SourceGeneratorBase<MessageDescriptor>, ISourceGenerator {
internal MessageGenerator(MessageDescriptor descriptor) : base(descriptor) {
}
private string ClassName {
get { return Descriptor.Name; }
}
private string FullClassName {
get { return DescriptorUtil.GetClassName(Descriptor); }
}
/// <summary>
/// Get an identifier that uniquely identifies this type within the file.
/// This is used to declare static variables related to this type at the
/// outermost file scope.
/// </summary>
static string GetUniqueFileScopeIdentifier(IDescriptor descriptor) {
return "static_" + descriptor.FullName.Replace(".", "_");
}
internal void GenerateStaticVariables(TextGenerator writer) {
// Because descriptor.proto (Google.ProtocolBuffers.DescriptorProtos) is
// used in the construction of descriptors, we have a tricky bootstrapping
// problem. To help control static initialization order, we make sure all
// descriptors and other static data that depends on them are members of
// the proto-descriptor class. This way, they will be initialized in
// a deterministic order.
string identifier = GetUniqueFileScopeIdentifier(Descriptor);
// The descriptor for this type.
string access = Descriptor.File.Options.GetExtension(CSharpOptions.CSharpNestClasses) ? "private" : "internal";
writer.WriteLine("{0} static readonly pbd::MessageDescriptor internal__{1}__Descriptor", access, identifier);
if (Descriptor.ContainingType == null) {
writer.WriteLine(" = Descriptor.MessageTypes[{0}];", Descriptor.Index);
} else {
writer.WriteLine(" = internal__{0}__Descriptor.NestedTypes[{1}];", GetUniqueFileScopeIdentifier(Descriptor.ContainingType), Descriptor.Index);
}
writer.WriteLine("{0} static pb::FieldAccess.FieldAccessorTable<{1}, {1}.Builder> internal__{2}__FieldAccessorTable",
access, FullClassName, identifier);
writer.WriteLine(" = new pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder>(internal__{1}__Descriptor,",
FullClassName, identifier);
writer.Print(" new string[] { ");
foreach (FieldDescriptor field in Descriptor.Fields) {
writer.Write("\"{0}\", ", Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(field)));
}
writer.WriteLine("});");
// Generate static members for all nested types.
foreach (MessageDescriptor nestedMessage in Descriptor.NestedTypes) {
new MessageGenerator(nestedMessage).GenerateStaticVariables(writer);
}
}
public void Generate(TextGenerator writer) {
writer.WriteLine("{0} sealed partial class {1} : pb::{2}Message<{1}, {1}.Builder> {{",
ClassAccessLevel, ClassName, Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated");
writer.Indent();
// Must call BuildPartial() to make sure all lists are made read-only
writer.WriteLine("private static readonly {0} defaultInstance = new Builder().BuildPartial();", ClassName);
writer.WriteLine("public static {0} DefaultInstance {{", ClassName);
writer.WriteLine(" get { return defaultInstance; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName);
writer.WriteLine(" get { return defaultInstance; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("protected override {0} ThisMessage {{", ClassName);
writer.WriteLine(" get { return this; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public static pbd::MessageDescriptor Descriptor {");
writer.WriteLine(" get {{ return {0}.internal__{1}__Descriptor; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor.File),
GetUniqueFileScopeIdentifier(Descriptor));
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("protected override pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder> InternalFieldAccessors {{", ClassName);
writer.WriteLine(" get {{ return {0}.internal__{1}__FieldAccessorTable; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor.File),
GetUniqueFileScopeIdentifier(Descriptor));
writer.WriteLine("}");
writer.WriteLine();
// Extensions don't need to go in an extra nested type
WriteChildren(writer, null, Descriptor.Extensions);
if (Descriptor.EnumTypes.Count + Descriptor.NestedTypes.Count > 0) {
writer.WriteLine("#region Nested types");
writer.WriteLine("public static class Types {");
writer.Indent();
WriteChildren(writer, null, Descriptor.EnumTypes);
WriteChildren(writer, null, Descriptor.NestedTypes);
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine("#endregion");
writer.WriteLine();
}
foreach(FieldDescriptor fieldDescriptor in Descriptor.Fields) {
// Rats: we lose the debug comment here :(
SourceGenerators.CreateFieldGenerator(fieldDescriptor).GenerateMembers(writer);
writer.WriteLine();
}
if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) {
GenerateIsInitialized(writer);
GenerateMessageSerializationMethods(writer);
}
GenerateParseFromMethods(writer);
GenerateBuilder(writer);
}
private void GenerateMessageSerializationMethods(TextGenerator writer) {
List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields);
sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber));
List<ExtensionRange> sortedExtensions = new List<ExtensionRange>(Descriptor.Proto.ExtensionRangeList);
sortedExtensions.Sort((r1, r2) => (r1.Start.CompareTo(r2.Start)));
writer.WriteLine("public override void WriteTo(pb::CodedOutputStream output) {");
writer.Indent();
if (Descriptor.Proto.ExtensionRangeList.Count > 0) {
writer.WriteLine("pb::ExtendableMessage<{0}, {0}.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);",
ClassName);
}
// Merge the fields and the extension ranges, both sorted by field number.
for (int i = 0, j = 0; i < Descriptor.Fields.Count || j < sortedExtensions.Count; ) {
if (i == Descriptor.Fields.Count) {
GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
} else if (j == sortedExtensions.Count) {
GenerateSerializeOneField(writer, sortedFields[i++]);
} else if (sortedFields[i].FieldNumber < sortedExtensions[j].Start) {
GenerateSerializeOneField(writer, sortedFields[i++]);
} else {
GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
}
}
if (Descriptor.Proto.Options.MessageSetWireFormat) {
writer.WriteLine("UnknownFields.WriteAsMessageSetTo(output);");
} else {
writer.WriteLine("UnknownFields.WriteTo(output);");
}
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("private int memoizedSerializedSize = -1;");
writer.WriteLine("public override int SerializedSize {");
writer.Indent();
writer.WriteLine("get {");
writer.Indent();
writer.WriteLine("int size = memoizedSerializedSize;");
writer.WriteLine("if (size != -1) return size;");
writer.WriteLine();
writer.WriteLine("size = 0;");
foreach (FieldDescriptor field in Descriptor.Fields) {
SourceGenerators.CreateFieldGenerator(field).GenerateSerializedSizeCode(writer);
}
if (Descriptor.Proto.ExtensionRangeCount > 0) {
writer.WriteLine("size += ExtensionsSerializedSize;");
}
if (Descriptor.Options.MessageSetWireFormat) {
writer.WriteLine("size += UnknownFields.SerializedSizeAsMessageSet;");
} else {
writer.WriteLine("size += UnknownFields.SerializedSize;");
}
writer.WriteLine("memoizedSerializedSize = size;");
writer.WriteLine("return size;");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
private static void GenerateSerializeOneField(TextGenerator writer, FieldDescriptor fieldDescriptor) {
SourceGenerators.CreateFieldGenerator(fieldDescriptor).GenerateSerializationCode(writer);
}
private static void GenerateSerializeOneExtensionRange(TextGenerator writer, ExtensionRange extensionRange) {
writer.WriteLine("extensionWriter.WriteUntil({0}, output);", extensionRange.End);
}
private void GenerateParseFromMethods(TextGenerator writer) {
// Note: These are separate from GenerateMessageSerializationMethods()
// because they need to be generated even for messages that are optimized
// for code size.
writer.WriteLine("public static {0} ParseFrom(pb::ByteString data) {{", ClassName);
writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();");
writer.WriteLine("}");
writer.WriteLine("public static {0} ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {{", ClassName);
writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();");
writer.WriteLine("}");
writer.WriteLine("public static {0} ParseFrom(byte[] data) {{", ClassName);
writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();");
writer.WriteLine("}");
writer.WriteLine("public static {0} ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {{", ClassName);
writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();");
writer.WriteLine("}");
writer.WriteLine("public static {0} ParseFrom(global::System.IO.Stream input) {{", ClassName);
writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();");
writer.WriteLine("}");
writer.WriteLine("public static {0} ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {{", ClassName);
writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();");
writer.WriteLine("}");
writer.WriteLine("public static {0} ParseFrom(pb::CodedInputStream input) {{", ClassName);
writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();");
writer.WriteLine("}");
writer.WriteLine("public static {0} ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {{", ClassName);
writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();");
writer.WriteLine("}");
}
/// <summary>
/// Returns whether or not the specified message type has any required fields.
/// If it doesn't, calls to check for initialization can be optimised.
/// TODO(jonskeet): Move this into MessageDescriptor?
/// </summary>
private static bool HasRequiredFields(MessageDescriptor descriptor, Dictionary<MessageDescriptor,object> alreadySeen) {
if (alreadySeen.ContainsKey(descriptor)) {
// The type is already in cache. This means that either:
// a. The type has no required fields.
// b. We are in the midst of checking if the type has required fields,
// somewhere up the stack. In this case, we know that if the type
// has any required fields, they'll be found when we return to it,
// and the whole call to HasRequiredFields() will return true.
// Therefore, we don't have to check if this type has required fields
// here.
return false;
}
alreadySeen[descriptor] = descriptor; // Value is irrelevant
// If the type has extensions, an extension with message type could contain
// required fields, so we have to be conservative and assume such an
// extension exists.
if (descriptor.Extensions.Count > 0) {
return true;
}
foreach (FieldDescriptor field in descriptor.Fields) {
if (field.IsRequired) {
return true;
}
// Message or group
if (field.MappedType == MappedType.Message) {
if (HasRequiredFields(field.MessageType, alreadySeen)) {
return true;
}
}
}
return false;
}
private void GenerateBuilder(TextGenerator writer) {
writer.WriteLine("public static Builder CreateBuilder() { return new Builder(); }");
writer.WriteLine("public override Builder CreateBuilderForType() { return new Builder(); }");
writer.WriteLine("public static Builder CreateBuilder({0} prototype) {{", ClassName);
writer.WriteLine(" return (Builder) new Builder().MergeFrom(prototype);");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("{0} sealed partial class Builder : pb::{2}Builder<{1}, Builder> {{",
ClassAccessLevel, ClassName, Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated");
writer.Indent();
writer.WriteLine("protected override Builder ThisBuilder {");
writer.WriteLine(" get { return this; }");
writer.WriteLine("}");
GenerateCommonBuilderMethods(writer);
if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) {
GenerateBuilderParsingMethods(writer);
}
foreach (FieldDescriptor field in Descriptor.Fields) {
writer.WriteLine();
// No field comment :(
SourceGenerators.CreateFieldGenerator(field).GenerateBuilderMembers(writer);
}
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
private void GenerateCommonBuilderMethods(TextGenerator writer) {
writer.WriteLine("{0} Builder() {{}}", ClassAccessLevel);
writer.WriteLine();
writer.WriteLine("{0} result = new {0}();", ClassName);
writer.WriteLine();
writer.WriteLine("protected override {0} MessageBeingBuilt {{", ClassName);
writer.WriteLine(" get { return result; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override Builder Clear() {");
writer.WriteLine(" result = new {0}();", ClassName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override Builder Clone() {");
writer.WriteLine(" return new Builder().MergeFrom(result);");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override pbd::MessageDescriptor DescriptorForType {");
writer.WriteLine(" get {{ return {0}.Descriptor; }}", ClassName);
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName);
writer.WriteLine(" get {{ return {0}.DefaultInstance; }}", ClassName);
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override {0} BuildPartial() {{", ClassName);
writer.Indent();
foreach (FieldDescriptor field in Descriptor.Fields) {
SourceGenerators.CreateFieldGenerator(field).GenerateBuildingCode(writer);
}
writer.WriteLine("{0} returnMe = result;", ClassName);
writer.WriteLine("result = null;");
writer.WriteLine("return returnMe;");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) {
writer.WriteLine("public override Builder MergeFrom(pb::IMessage other) {");
writer.WriteLine(" if (other is {0}) {{", ClassName);
writer.WriteLine(" return MergeFrom(({0}) other);", ClassName);
writer.WriteLine(" } else {");
writer.WriteLine(" base.MergeFrom(other);");
writer.WriteLine(" return this;");
writer.WriteLine(" }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override Builder MergeFrom({0} other) {{", ClassName);
// Optimization: If other is the default instance, we know none of its
// fields are set so we can skip the merge.
writer.Indent();
writer.WriteLine("if (other == {0}.DefaultInstance) return this;", ClassName);
foreach (FieldDescriptor field in Descriptor.Fields) {
SourceGenerators.CreateFieldGenerator(field).GenerateMergingCode(writer);
}
writer.WriteLine("this.MergeUnknownFields(other.UnknownFields);");
writer.WriteLine("return this;");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
}
private void GenerateBuilderParsingMethods(TextGenerator writer) {
List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields);
sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber));
writer.WriteLine("public override Builder MergeFrom(pb::CodedInputStream input) {");
writer.WriteLine(" return MergeFrom(input, pb::ExtensionRegistry.Empty);");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {");
writer.Indent();
writer.WriteLine("pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);");
writer.WriteLine("while (true) {");
writer.Indent();
writer.WriteLine("uint tag = input.ReadTag();");
writer.WriteLine("switch (tag) {");
writer.Indent();
writer.WriteLine("case 0: {"); // 0 signals EOF / limit reached
writer.WriteLine(" this.UnknownFields = unknownFields.Build();");
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("default: {");
writer.WriteLine(" if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {");
writer.WriteLine(" this.UnknownFields = unknownFields.Build();");
writer.WriteLine(" return this;"); // it's an endgroup tag
writer.WriteLine(" }");
writer.WriteLine(" break;");
writer.WriteLine("}");
foreach (FieldDescriptor field in sortedFields) {
uint tag = WireFormat.MakeTag(field.FieldNumber, WireFormat.GetWireType(field.FieldType));
writer.WriteLine("case {0}: {{", tag);
writer.Indent();
SourceGenerators.CreateFieldGenerator(field).GenerateParsingCode(writer);
writer.WriteLine("break;");
writer.Outdent();
writer.WriteLine("}");
}
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
private void GenerateIsInitialized(TextGenerator writer) {
writer.WriteLine("public override bool IsInitialized {");
writer.Indent();
writer.WriteLine("get {");
writer.Indent();
// Check that all required fields in this message are set.
// TODO(kenton): We can optimize this when we switch to putting all the
// "has" fields into a single bitfield.
foreach (FieldDescriptor field in Descriptor.Fields) {
if (field.IsRequired) {
writer.WriteLine("if (!has{0}) return false;", Helpers.UnderscoresToPascalCase(field.Name));
}
}
// Now check that all embedded messages are initialized.
foreach (FieldDescriptor field in Descriptor.Fields) {
if (field.FieldType != FieldType.Message ||
!HasRequiredFields(field.MessageType, new Dictionary<MessageDescriptor, object>())) {
continue;
}
string propertyName = Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(field));
if (field.IsRepeated) {
writer.WriteLine("foreach ({0} element in {1}List) {{", DescriptorUtil.GetClassName(field.MessageType), propertyName);
writer.WriteLine(" if (!element.IsInitialized) return false;");
writer.WriteLine("}");
} else if (field.IsOptional) {
writer.WriteLine("if (Has{0}) {{", propertyName);
writer.WriteLine(" if (!{0}.IsInitialized) return false;", propertyName);
writer.WriteLine("}");
} else {
writer.WriteLine("if (!{0}.IsInitialized) return false;", propertyName);
}
}
if (Descriptor.Extensions.Count > 0) {
writer.WriteLine("if (!ExtensionsAreInitialized) return false;");
}
writer.WriteLine("return true;");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
}
}

70
csharp/ProtoGen/PrimitiveFieldGenerator.cs
View file

@ -1,70 +0,0 @@
using System;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
// TODO(jonskeet): Refactor this. There's loads of common code here.
internal class PrimitiveFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
internal PrimitiveFieldGenerator(FieldDescriptor descriptor)
: base(descriptor) {
}
public void GenerateMembers(TextGenerator writer) {
writer.WriteLine("private bool has{0};", CapitalizedName);
writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue);
writer.WriteLine("public bool Has{0} {{", CapitalizedName);
writer.WriteLine(" get {{ return has{0}; }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return {0}_; }}", Name);
writer.WriteLine("}");
}
public void GenerateBuilderMembers(TextGenerator writer) {
writer.WriteLine("public bool Has{0} {{", CapitalizedName);
writer.WriteLine(" get {{ return result.Has{0}; }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return result.{0}; }}", PropertyName);
writer.WriteLine(" set {{ Set{0}(value); }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}({1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.has{0} = true;", CapitalizedName);
writer.WriteLine(" result.{0}_ = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
writer.WriteLine(" result.has{0} = false;", CapitalizedName);
writer.WriteLine(" result.{0}_ = {1};", Name, DefaultValue);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateMergingCode(TextGenerator writer) {
writer.WriteLine("if (other.Has{0}) {{", CapitalizedName);
writer.WriteLine(" {0} = other.{0};", PropertyName);
writer.WriteLine("}");
}
public void GenerateBuildingCode(TextGenerator writer) {
// Nothing to do here for primitive types
}
public void GenerateParsingCode(TextGenerator writer) {
writer.WriteLine("{0} = input.Read{1}();", PropertyName, CapitalizedTypeName);
}
public void GenerateSerializationCode(TextGenerator writer) {
writer.WriteLine("if (Has{0}) {{", CapitalizedName);
writer.WriteLine(" output.Write{0}({1}, {2});", CapitalizedTypeName, Number, PropertyName);
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer) {
writer.WriteLine("if (Has{0}) {{", CapitalizedName);
writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, {2});",
CapitalizedTypeName, Number, PropertyName);
writer.WriteLine("}");
}
}
}

47
csharp/ProtoGen/Program.cs
View file

@ -1,47 +0,0 @@
using System;
using System.Collections.Generic;
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// Entry point for the Protocol Buffers generator.
/// </summary>
class Program {
static int Main(string[] args) {
try {
// Hack to make sure everything's initialized
DescriptorProtoFile.Descriptor.ToString();
GeneratorOptions options = ParseCommandLineArguments(args);
IList<string> validationFailures;
if (!options.TryValidate(out validationFailures)) {
// We've already got the message-building logic in the exception...
InvalidOptionsException exception = new InvalidOptionsException(validationFailures);
Console.WriteLine(exception.Message);
return 1;
}
Generator generator = Generator.CreateGenerator(options);
generator.Generate();
return 0;
} catch (Exception e) {
Console.Error.WriteLine("Error: {0}", e.Message);
Console.Error.WriteLine();
Console.Error.WriteLine("Detailed exception information: {0}", e);
return 1;
}
}
private static GeneratorOptions ParseCommandLineArguments(string[] args) {
GeneratorOptions options = new GeneratorOptions();
//string baseDir = "c:\\Users\\Jon\\Documents\\Visual Studio 2008\\Projects\\ProtocolBuffers";
//options.OutputDirectory = baseDir + "\\tmp";
//options.InputFiles = new[] { baseDir + "\\protos\\nwind-solo.protobin" };
options.OutputDirectory = ".";
options.InputFiles = args;
return options;
}
}
}

42
csharp/ProtoGen/Properties/AssemblyInfo.cs
View file

@ -1,42 +0,0 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ProtoGen")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ProtoGen")]
[assembly: AssemblyCopyright("Copyright © 2008")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("7101763b-7a38-41be-87f5-7ede4c554509")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: InternalsVisibleTo("Google.ProtocolBuffers.ProtoGen.Test,PublicKey=" +
"0024000004800000940000000602000000240000525341310004000001000100cf43741ffc3e65" +
"c85707245e144e90f1bb82f20d1b1555846008d4d5d5c9270a980350dcb1ddd40fcdde13c2780c" +
"75c9057123daa5613cb6551e2b8bd2254e8f84b3893369869e5119b752442aef7156c4defc489b" +
"96c44ff801fe8d94199e048f8ff414813c9c811a029bcd697040700dc66982539e9b368cb5e725" +
"feed60f2")]

BIN
csharp/ProtoGen/Properties/Google.ProtocolBuffers.ProtoGen.snk
View file

Binary file not shown.

85
csharp/ProtoGen/ProtoGen.csproj
View file

@ -1,85 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{250ADE34-82FD-4BAE-86D5-985FBE589C4A}</ProjectGuid>
<OutputType>Exe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Google.ProtocolBuffers.ProtoGen</RootNamespace>
<AssemblyName>ProtoGen</AssemblyName>
<TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<TargetFrameworkSubset>
</TargetFrameworkSubset>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>Properties\Google.ProtocolBuffers.ProtoGen.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
</ItemGroup>
<ItemGroup>
<Compile Include="DescriptorUtil.cs" />
<Compile Include="EnumFieldGenerator.cs" />
<Compile Include="EnumGenerator.cs" />
<Compile Include="ExtensionGenerator.cs" />
<Compile Include="FieldGeneratorBase.cs" />
<Compile Include="IFieldSourceGenerator.cs" />
<Compile Include="ISourceGenerator.cs" />
<Compile Include="MessageFieldGenerator.cs" />
<Compile Include="MessageGenerator.cs" />
<Compile Include="PrimitiveFieldGenerator.cs" />
<Compile Include="RepeatedEnumFieldGenerator.cs" />
<Compile Include="RepeatedMessageFieldGenerator.cs" />
<Compile Include="RepeatedPrimitiveFieldGenerator.cs" />
<Compile Include="ServiceGenerator.cs" />
<Compile Include="SourceFileGenerator.cs" />
<Compile Include="DependencyResolutionException.cs" />
<Compile Include="Generator.cs" />
<Compile Include="GeneratorOptions.cs" />
<Compile Include="Helpers.cs" />
<Compile Include="InvalidOptionsException.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="SourceGeneratorBase.cs" />
<Compile Include="SourceGenerators.cs" />
<Compile Include="UmbrellaClassGenerator.cs" />
</ItemGroup>
<ItemGroup>
<None Include="app.config" />
<None Include="Properties\Google.ProtocolBuffers.ProtoGen.snk" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj">
<Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project>
<Name>ProtocolBuffers</Name>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

6
csharp/ProtoGen/ProtoGen.csproj.user
View file

@ -1,6 +0,0 @@
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<StartWorkingDirectory>c:\Users\Jon\Documents\Visual Studio 2008\Projects\ProtocolBuffers\csharp\testprotos</StartWorkingDirectory>
<StartArguments>unittest.protobin</StartArguments>
</PropertyGroup>
</Project>

90
csharp/ProtoGen/RepeatedEnumFieldGenerator.cs
View file

@ -1,90 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal class RepeatedEnumFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
internal RepeatedEnumFieldGenerator(FieldDescriptor descriptor)
: base(descriptor) {
}
public void GenerateMembers(TextGenerator writer) {
writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
writer.WriteLine(" get {{ return pbc::Lists.AsReadOnly({0}_); }}", Name);
writer.WriteLine("}");
// TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option.
writer.WriteLine("public int {0}Count {{", CapitalizedName);
writer.WriteLine(" get {{ return {0}_.Count; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
writer.WriteLine(" return {0}_[index];", Name);
writer.WriteLine("}");
}
public void GenerateBuilderMembers(TextGenerator writer) {
// Note: We can return the original list here, because we make it unmodifiable when we build
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
writer.WriteLine(" get {{ return result.{0}_; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public int {0}Count {{", CapitalizedName);
writer.WriteLine(" get {{ return result.{0}Count; }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
writer.WriteLine(" return result.Get{0}(index);", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.{0}_[index] = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Add{0}({1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.{0}_.Add(value);", Name, TypeName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", CapitalizedName, TypeName);
writer.WriteLine(" base.AddRange(values, result.{0}_);", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
writer.WriteLine(" result.{0}_.Clear();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateMergingCode(TextGenerator writer) {
writer.WriteLine("if (other.{0}_.Count != 0) {{", Name);
writer.WriteLine(" base.AddRange(other.{0}_, result.{0}_);", Name);
writer.WriteLine("}");
}
public void GenerateBuildingCode(TextGenerator writer) {
writer.WriteLine("result.{0}_.MakeReadOnly();", Name);
}
public void GenerateParsingCode(TextGenerator writer) {
// TODO(jonskeet): Make a more efficient way of doing this
writer.WriteLine("int rawValue = input.ReadEnum();");
writer.WriteLine("if (!global::System.Enum.IsDefined(typeof({0}), rawValue)) {{", TypeName);
writer.WriteLine(" unknownFields.MergeVarintField({0}, (ulong) rawValue);", Number);
writer.WriteLine("} else {");
writer.WriteLine(" Add{0}({1} rawValue);", CapitalizedName, TypeName);
writer.WriteLine("}");
}
public void GenerateSerializationCode(TextGenerator writer) {
writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
writer.WriteLine(" output.WriteEnum({0}, (int) element);", Number);
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer) {
writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
writer.WriteLine(" size += pb::CodedOutputStream.ComputeEnumSize({0}, (int) element);", Number);
writer.WriteLine("}");
}
}
}

100
csharp/ProtoGen/RepeatedMessageFieldGenerator.cs
View file

@ -1,100 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal class RepeatedMessageFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
internal RepeatedMessageFieldGenerator(FieldDescriptor descriptor)
: base(descriptor) {
}
public void GenerateMembers(TextGenerator writer) {
writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
writer.WriteLine(" get {{ return {0}_; }}", Name);
writer.WriteLine("}");
// TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option.
writer.WriteLine("public int {0}Count {{", CapitalizedName);
writer.WriteLine(" get {{ return {0}_.Count; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
writer.WriteLine(" return {0}_[index];", Name);
writer.WriteLine("}");
}
public void GenerateBuilderMembers(TextGenerator writer) {
// Note: We can return the original list here, because we make it unmodifiable when we build
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
writer.WriteLine(" get {{ return result.{0}_; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public int {0}Count {{", CapitalizedName);
writer.WriteLine(" get {{ return result.{0}Count; }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
writer.WriteLine(" return result.Get{0}(index);", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.{0}_[index] = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
// Extra overload for builder (just on messages)
writer.WriteLine("public Builder Set{0}(int index, {1}.Builder builderForValue) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.{0}_[index] = builderForValue.Build();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Add{0}({1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.{0}_.Add(value);", Name, TypeName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
// Extra overload for builder (just on messages)
writer.WriteLine("public Builder Add{0}({1}.Builder builderForValue) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.{0}_.Add(builderForValue.Build());", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", CapitalizedName, TypeName);
writer.WriteLine(" base.AddRange(values, result.{0}_);", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
writer.WriteLine(" result.{0}_.Clear();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateMergingCode(TextGenerator writer) {
writer.WriteLine("if (other.{0}_.Count != 0) {{", Name);
writer.WriteLine(" base.AddRange(other.{0}_, result.{0}_);", Name);
writer.WriteLine("}");
}
public void GenerateBuildingCode(TextGenerator writer) {
writer.WriteLine("result.{0}_.MakeReadOnly();", Name);
}
public void GenerateParsingCode(TextGenerator writer) {
writer.WriteLine("{0}.Builder subBuilder = {0}.CreateBuilder();", TypeName);
if (Descriptor.FieldType == FieldType.Group) {
writer.WriteLine("input.ReadGroup({0}, subBuilder, extensionRegistry);", Number);
} else {
writer.WriteLine("input.ReadMessage(subBuilder, extensionRegistry);");
}
writer.WriteLine("Add{0}(subBuilder.BuildPartial());", CapitalizedName);
}
public void GenerateSerializationCode(TextGenerator writer) {
writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
writer.WriteLine(" output.Write{0}({1}, element);", MessageOrGroup, Number);
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer) {
writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, element);", MessageOrGroup, Number);
writer.WriteLine("}");
}
}
}

84
csharp/ProtoGen/RepeatedPrimitiveFieldGenerator.cs
View file

@ -1,84 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal class RepeatedPrimitiveFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
internal RepeatedPrimitiveFieldGenerator(FieldDescriptor descriptor)
: base(descriptor) {
}
public void GenerateMembers(TextGenerator writer) {
writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
writer.WriteLine(" get {{ return pbc::Lists.AsReadOnly({0}_); }}", Name);
writer.WriteLine("}");
// TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option.
writer.WriteLine("public int {0}Count {{", CapitalizedName);
writer.WriteLine(" get {{ return {0}_.Count; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
writer.WriteLine(" return {0}_[index];", Name);
writer.WriteLine("}");
}
public void GenerateBuilderMembers(TextGenerator writer) {
// Note: We can return the original list here, because we make it unmodifiable when we build
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
writer.WriteLine(" get {{ return result.{0}_; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public int {0}Count {{", CapitalizedName);
writer.WriteLine(" get {{ return result.{0}Count; }}", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
writer.WriteLine(" return result.Get{0}(index);", CapitalizedName);
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.{0}_[index] = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Add{0}({1} value) {{", CapitalizedName, TypeName);
writer.WriteLine(" result.{0}_.Add(value);", Name, TypeName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", CapitalizedName, TypeName);
writer.WriteLine(" base.AddRange(values, result.{0}_);", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
writer.WriteLine(" result.{0}_.Clear();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateMergingCode(TextGenerator writer) {
writer.WriteLine("if (other.{0}_.Count != 0) {{", Name);
writer.WriteLine(" base.AddRange(other.{0}_, result.{0}_);", Name);
writer.WriteLine("}");
}
public void GenerateBuildingCode(TextGenerator writer) {
writer.WriteLine("result.{0}_.MakeReadOnly();", Name);
}
public void GenerateParsingCode(TextGenerator writer) {
writer.WriteLine("Add{0}(input.Read{1}());", CapitalizedName, CapitalizedTypeName);
}
public void GenerateSerializationCode(TextGenerator writer) {
writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
writer.WriteLine(" output.Write{0}({1}, element);", CapitalizedTypeName, Number);
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer) {
writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, element);", CapitalizedTypeName, Number);
writer.WriteLine("}");
}
}
}

138
csharp/ProtoGen/ServiceGenerator.cs
View file

@ -1,138 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal class ServiceGenerator : SourceGeneratorBase<ServiceDescriptor>, ISourceGenerator {
private enum RequestOrResponse {
Request,
Response
}
internal ServiceGenerator(ServiceDescriptor descriptor)
: base(descriptor) {
}
public void Generate(TextGenerator writer) {
writer.WriteLine("{0} abstract class {1} : pb::IService {{", ClassAccessLevel, Descriptor.Name);
writer.Indent();
foreach (MethodDescriptor method in Descriptor.Methods) {
writer.WriteLine("{0} abstract void {1}(", ClassAccessLevel, Helpers.UnderscoresToPascalCase(method.Name));
writer.WriteLine(" pb::IRpcController controller,");
writer.WriteLine(" {0} request,", DescriptorUtil.GetClassName(method.InputType));
writer.WriteLine(" global::System.Action<{0}> done);", DescriptorUtil.GetClassName(method.OutputType));
}
// Generate Descriptor and DescriptorForType.
writer.WriteLine();
writer.WriteLine("{0} static pbd::ServiceDescriptor Descriptor {{", ClassAccessLevel);
writer.WriteLine(" get {{ return {0}.Descriptor.Services[{1}]; }}",
DescriptorUtil.GetUmbrellaClassName(Descriptor.File), Descriptor.Index);
writer.WriteLine("}");
writer.WriteLine("{0} pbd::ServiceDescriptor DescriptorForType {{", ClassAccessLevel);
writer.WriteLine(" get { return Descriptor; }");
writer.WriteLine("}");
GenerateCallMethod(writer);
GenerateGetPrototype(RequestOrResponse.Request, writer);
GenerateGetPrototype(RequestOrResponse.Response, writer);
GenerateStub(writer);
writer.Outdent();
writer.WriteLine("}");
}
private void GenerateCallMethod(TextGenerator writer) {
writer.WriteLine();
writer.WriteLine("public void CallMethod(", ClassAccessLevel);
writer.WriteLine(" pbd::MethodDescriptor method,");
writer.WriteLine(" pb::IRpcController controller,");
writer.WriteLine(" pb::IMessage request,");
writer.WriteLine(" global::System.Action<pb::IMessage> done) {");
writer.Indent();
writer.WriteLine("if (method.Service != Descriptor) {");
writer.WriteLine(" throw new global::System.ArgumentException(");
writer.WriteLine(" \"Service.CallMethod() given method descriptor for wrong service type.\");");
writer.WriteLine("}");
writer.WriteLine("switch(method.Index) {");
writer.Indent();
foreach (MethodDescriptor method in Descriptor.Methods) {
writer.WriteLine("case {0}:", method.Index);
writer.WriteLine(" this.{0}(controller, ({0}) request,",
Helpers.UnderscoresToPascalCase(method.Name), DescriptorUtil.GetClassName(method.InputType));
writer.WriteLine(" pb::RpcUtil.SpecializeCallback<{0}>(", DescriptorUtil.GetClassName(method.OutputType));
writer.WriteLine(" done));");
writer.WriteLine(" return;");
}
writer.WriteLine("default:");
writer.WriteLine(" throw new global::System.InvalidOperationException(\"Can't get here.\");");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
private void GenerateGetPrototype(RequestOrResponse which, TextGenerator writer) {
writer.WriteLine("public pb::IMessage Get{0}Prototype(pbd::MethodDescriptor method) {{", which);
writer.Indent();
writer.WriteLine("if (method.Service != Descriptor) {");
writer.WriteLine(" throw new global::System.ArgumentException(");
writer.WriteLine(" \"Service.Get{0}Prototype() given method descriptor for wrong service type.\");", which);
writer.WriteLine("}");
writer.WriteLine("switch(method.Index) {");
writer.Indent();
foreach (MethodDescriptor method in Descriptor.Methods) {
writer.WriteLine("case {0}:", method.Index);
writer.WriteLine(" return {0}.DefaultInstance;",
DescriptorUtil.GetClassName(which == RequestOrResponse.Request ? method.InputType : method.OutputType));
}
writer.WriteLine("default:");
writer.WriteLine(" throw new global::System.InvalidOperationException(\"Can't get here.\");");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
private void GenerateStub(TextGenerator writer) {
writer.WriteLine("public static Stub CreateStub(pb::IRpcChannel channel) {");
writer.WriteLine(" return new Stub(channel);");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("{0} class Stub : {1} {{", ClassAccessLevel, DescriptorUtil.GetClassName(Descriptor));
writer.Indent();
writer.WriteLine("internal Stub(pb::IRpcChannel channel) {");
writer.WriteLine(" this.channel = channel;");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("private readonly pb::IRpcChannel channel;");
writer.WriteLine();
writer.WriteLine("public pb::IRpcChannel Channel {");
writer.WriteLine(" get { return channel; }");
writer.WriteLine("}");
foreach (MethodDescriptor method in Descriptor.Methods) {
writer.WriteLine();
writer.WriteLine("public override void {0}(", Helpers.UnderscoresToPascalCase(method.Name));
writer.WriteLine(" pb::IRpcController controller,");
writer.WriteLine(" {0} request,", DescriptorUtil.GetClassName(method.InputType));
writer.WriteLine(" global::System.Action<{0}> done) {{", DescriptorUtil.GetClassName(method.OutputType));
writer.Indent();
writer.WriteLine("channel.CallMethod(Descriptor.Methods[{0}],", method.Index);
writer.WriteLine(" controller, request, {0}.DefaultInstance,", DescriptorUtil.GetClassName(method.OutputType));
writer.WriteLine(" pb::RpcUtil.GeneralizeCallback<{0}, {0}.Builder>(done, {0}.DefaultInstance));",
DescriptorUtil.GetClassName(method.OutputType));
writer.Outdent();
writer.WriteLine("}");
}
writer.Outdent();
writer.WriteLine("}");
}
}
}

29
csharp/ProtoGen/SourceFileGenerator.cs
View file

@ -1,29 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// Generator to hold a TextGenerator, generate namespace aliases etc.
/// Each source file created uses one of these, and it can be used to create
/// multiple classes within the same file.
/// </summary>
internal class SourceFileGenerator {
private readonly TextGenerator output;
private SourceFileGenerator(TextWriter writer) {
output = new TextGenerator(writer);
}
/// <summary>
/// Creates a ClassFileGenerator for the given writer, which will be closed
/// when the instance is disposed. The specified namespace is created, if it's non-null.
/// </summary>
internal static SourceFileGenerator ForWriter(TextWriter writer) {
return new SourceFileGenerator(writer);
}
}
}

50
csharp/ProtoGen/SourceGeneratorBase.cs
View file

@ -1,50 +0,0 @@
using System.Collections.Generic;
using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal abstract class SourceGeneratorBase<T> where T : IDescriptor {
private readonly T descriptor;
protected SourceGeneratorBase(T descriptor) {
this.descriptor = descriptor;
}
protected T Descriptor {
get { return descriptor; }
}
protected string ClassAccessLevel {
get {
// Default to public
return !descriptor.File.Options.HasExtension(CSharpOptions.CSharpPublicClasses)
|| descriptor.File.Options.GetExtension(CSharpOptions.CSharpPublicClasses) ? "public" : "internal";
}
}
public bool MultipleFiles {
get { return descriptor.File.Options.GetExtension(CSharpOptions.CSharpMultipleFiles); }
}
protected static void WriteChildren<TChild>(TextGenerator writer, string region, IEnumerable<TChild> children)
where TChild : IDescriptor {
// Copy the set of children; makes access easier
List<TChild> copy = new List<TChild>(children);
if (copy.Count == 0) {
return;
}
if (region != null) {
writer.WriteLine("#region {0}", region);
}
foreach (TChild child in children) {
SourceGenerators.CreateGenerator(child).Generate(writer);
}
if (region != null) {
writer.WriteLine("#endregion");
writer.WriteLine();
}
}
}
}

42
csharp/ProtoGen/SourceGenerators.cs
View file

@ -1,42 +0,0 @@
using System;
using System.Collections.Generic;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
internal static class SourceGenerators {
private static readonly Dictionary<Type, Func<IDescriptor, ISourceGenerator>> GeneratorFactories = new Dictionary<Type, Func<IDescriptor, ISourceGenerator>> {
{ typeof(FileDescriptor), descriptor => new UmbrellaClassGenerator((FileDescriptor) descriptor) },
{ typeof(EnumDescriptor), descriptor => new EnumGenerator((EnumDescriptor) descriptor) },
{ typeof(ServiceDescriptor), descriptor => new ServiceGenerator((ServiceDescriptor) descriptor) },
{ typeof(MessageDescriptor), descriptor => new MessageGenerator((MessageDescriptor) descriptor) },
// For other fields, we have IFieldSourceGenerators.
{ typeof(FieldDescriptor), descriptor => new ExtensionGenerator((FieldDescriptor) descriptor) }
};
public static IFieldSourceGenerator CreateFieldGenerator(FieldDescriptor field) {
switch (field.MappedType) {
case MappedType.Message :
return field.IsRepeated
? (IFieldSourceGenerator) new RepeatedMessageFieldGenerator(field)
: new MessageFieldGenerator(field);
case MappedType.Enum:
return field.IsRepeated
? (IFieldSourceGenerator)new RepeatedEnumFieldGenerator(field)
: new EnumFieldGenerator(field);
default:
return field.IsRepeated
? (IFieldSourceGenerator)new RepeatedPrimitiveFieldGenerator(field)
: new PrimitiveFieldGenerator(field);
}
}
public static ISourceGenerator CreateGenerator<T>(T descriptor) where T : IDescriptor {
Func<IDescriptor, ISourceGenerator> factory;
if (!GeneratorFactories.TryGetValue(typeof(T), out factory)) {
throw new ArgumentException("No generator registered for " + typeof(T).Name);
}
return factory(descriptor);
}
}
}

96
csharp/ProtoGen/UmbrellaClassGenerator.cs
View file

@ -1,96 +0,0 @@
using System;
using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
/// <summary>
/// Generator for the class describing the .proto file in general,
/// containing things like the message descriptor.
/// </summary>
internal sealed class UmbrellaClassGenerator : SourceGeneratorBase<FileDescriptor>, ISourceGenerator {
internal UmbrellaClassGenerator(FileDescriptor descriptor)
: base(descriptor) {
}
public void Generate(TextGenerator writer) {
WriteIntroduction(writer);
WriteDescriptor(writer);
WriteChildren(writer, "Extensions", Descriptor.Extensions);
writer.WriteLine("#region Static variables");
foreach (MessageDescriptor message in Descriptor.MessageTypes) {
new MessageGenerator(message).GenerateStaticVariables(writer);
}
writer.WriteLine("#endregion");
// The class declaration either gets closed before or after the children are written.
if (!DescriptorUtil.NestClasses(Descriptor)) {
writer.Outdent();
writer.WriteLine("}");
}
WriteChildren(writer, "Enums", Descriptor.EnumTypes);
WriteChildren(writer, "Messages", Descriptor.MessageTypes);
WriteChildren(writer, "Services", Descriptor.Services);
if (DescriptorUtil.NestClasses(Descriptor)) {
writer.Outdent();
writer.WriteLine("}");
}
if (DescriptorUtil.GetNamespace(Descriptor) != "") {
writer.Outdent();
writer.WriteLine("}");
}
}
private void WriteIntroduction(TextGenerator writer) {
writer.WriteLine("// Generated by the protocol buffer compiler. DO NOT EDIT!");
writer.WriteLine();
Helpers.WriteNamespaces(writer);
if (DescriptorUtil.GetNamespace(Descriptor) != "") {
writer.WriteLine("namespace {0} {{", DescriptorUtil.GetNamespace(Descriptor));
writer.Indent();
writer.WriteLine();
}
writer.WriteLine("{0} static partial class {1} {{", ClassAccessLevel, DescriptorUtil.GetUmbrellaClassName(Descriptor));
writer.WriteLine();
writer.Indent();
}
private void WriteDescriptor(TextGenerator writer) {
writer.WriteLine("#region Descriptor");
writer.WriteLine("public static pbd::FileDescriptor Descriptor {");
writer.WriteLine(" get { return descriptor; }");
writer.WriteLine("}");
writer.WriteLine("private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom(");
writer.WriteLine(" global::System.Convert.FromBase64String(");
writer.Indent();
writer.Indent();
// TODO(jonskeet): Consider a C#-escaping format here instead of just Base64.
byte[] bytes = Descriptor.Proto.ToByteArray();
string base64 = Convert.ToBase64String(bytes);
while (base64.Length > 60) {
writer.WriteLine("\"{0}\" + ", base64.Substring(0, 60));
base64 = base64.Substring(60);
}
writer.WriteLine("\"{0}\"),", base64);
writer.WriteLine("new pbd::FileDescriptor[] {");
foreach (FileDescriptor dependency in Descriptor.Dependencies) {
// TODO(jonskeet): The normal code won't work for the bootstrapping descriptor, because we don't get unknown fields :(
if (dependency.Package == "google.protobuf" && dependency.Name.EndsWith("descriptor.proto")) {
writer.WriteLine(" global::" + typeof(DescriptorProtoFile).FullName + ".Descriptor, ");
continue;
}
writer.WriteLine(" {0}.Descriptor, ", DescriptorUtil.GetFullUmbrellaClassName(dependency));
}
writer.WriteLine("});");
writer.Outdent();
writer.Outdent();
writer.WriteLine("#endregion");
writer.WriteLine();
}
}
}

3
csharp/ProtoGen/app.config
View file

@ -1,3 +0,0 @@
<?xml version="1.0"?>
<configuration>
<startup><supportedRuntime version="v2.0.50727"/></startup></configuration>

364
csharp/ProtocolBuffers.Test/AbstractMessageTest.cs
View file

@ -1,364 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections.Generic;
using Google.ProtocolBuffers.Descriptors;
using NUnit.Framework;
using Google.ProtocolBuffers.TestProtos;
namespace Google.ProtocolBuffers {
[TestFixture]
public class AbstractMessageTest {
[Test]
public void Clear() {
AbstractMessageWrapper message = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder(TestUtil.GetAllSet())).Clear().Build();
TestUtil.AssertClear((TestAllTypes) message.WrappedMessage);
}
[Test]
public void Copy() {
AbstractMessageWrapper message = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder()).MergeFrom(TestUtil.GetAllSet()).Build();
TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage);
}
[Test]
public void SerializedSize() {
TestAllTypes message = TestUtil.GetAllSet();
IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet());
Assert.AreEqual(message.SerializedSize, abstractMessage.SerializedSize);
}
[Test]
public void Serialization() {
IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet());
TestUtil.AssertAllFieldsSet(TestAllTypes.ParseFrom(abstractMessage.ToByteString()));
Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), abstractMessage.ToByteString());
}
[Test]
public void Parsing() {
IBuilder builder = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder());
AbstractMessageWrapper message = (AbstractMessageWrapper) builder.WeakMergeFrom(TestUtil.GetAllSet().ToByteString()).WeakBuild();
TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage);
}
[Test]
public void OptimizedForSize() {
// We're mostly only Checking that this class was compiled successfully.
TestOptimizedForSize message = TestOptimizedForSize.CreateBuilder().SetI(1).Build();
message = TestOptimizedForSize.ParseFrom(message.ToByteString());
Assert.AreEqual(2, message.SerializedSize);
}
// -----------------------------------------------------------------
// Tests for isInitialized().
private static readonly TestRequired TestRequiredUninitialized = TestRequired.DefaultInstance;
private static readonly TestRequired TestRequiredInitialized = TestRequired.CreateBuilder().SetA(1).SetB(2).SetC(3).Build();
[Test]
public void IsInitialized() {
TestRequired.Builder builder = TestRequired.CreateBuilder();
AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder);
Assert.IsFalse(abstractBuilder.IsInitialized);
builder.A = 1;
Assert.IsFalse(abstractBuilder.IsInitialized);
builder.B = 1;
Assert.IsFalse(abstractBuilder.IsInitialized);
builder.C = 1;
Assert.IsTrue(abstractBuilder.IsInitialized);
}
[Test]
public void ForeignIsInitialized() {
TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder();
AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder);
Assert.IsTrue(abstractBuilder.IsInitialized);
builder.SetOptionalMessage(TestRequiredUninitialized);
Assert.IsFalse(abstractBuilder.IsInitialized);
builder.SetOptionalMessage(TestRequiredInitialized);
Assert.IsTrue(abstractBuilder.IsInitialized);
builder.AddRepeatedMessage(TestRequiredUninitialized);
Assert.IsFalse(abstractBuilder.IsInitialized);
builder.SetRepeatedMessage(0, TestRequiredInitialized);
Assert.IsTrue(abstractBuilder.IsInitialized);
}
// -----------------------------------------------------------------
// Tests for mergeFrom
static readonly TestAllTypes MergeSource = TestAllTypes.CreateBuilder()
.SetOptionalInt32(1)
.SetOptionalString("foo")
.SetOptionalForeignMessage(ForeignMessage.DefaultInstance)
.AddRepeatedString("bar")
.Build();
static readonly TestAllTypes MergeDest = TestAllTypes.CreateBuilder()
.SetOptionalInt64(2)
.SetOptionalString("baz")
.SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(3).Build())
.AddRepeatedString("qux")
.Build();
const string MergeResultText = "optional_int32: 1\n" +
"optional_int64: 2\n" +
"optional_string: \"foo\"\n" +
"optional_foreign_message {\n" +
" c: 3\n" +
"}\n" +
"repeated_string: \"qux\"\n" +
"repeated_string: \"bar\"\n";
[Test]
public void MergeFrom() {
AbstractMessageWrapper result = (AbstractMessageWrapper)
new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder(MergeDest))
.MergeFrom(MergeSource)
.Build();
Assert.AreEqual(MergeResultText, result.ToString());
}
// -----------------------------------------------------------------
// Tests for equals and hashCode
[Test]
public void EqualsAndHashCode() {
TestAllTypes a = TestUtil.GetAllSet();
TestAllTypes b = TestAllTypes.CreateBuilder().Build();
TestAllTypes c = TestAllTypes.CreateBuilder(b).AddRepeatedString("x").Build();
TestAllTypes d = TestAllTypes.CreateBuilder(c).AddRepeatedString("y").Build();
TestAllExtensions e = TestUtil.GetAllExtensionsSet();
TestAllExtensions f = TestAllExtensions.CreateBuilder(e)
.AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 999).Build();
CheckEqualsIsConsistent(a);
CheckEqualsIsConsistent(b);
CheckEqualsIsConsistent(c);
CheckEqualsIsConsistent(d);
CheckEqualsIsConsistent(e);
CheckEqualsIsConsistent(f);
CheckNotEqual(a, b);
CheckNotEqual(a, c);
CheckNotEqual(a, d);
CheckNotEqual(a, e);
CheckNotEqual(a, f);
CheckNotEqual(b, c);
CheckNotEqual(b, d);
CheckNotEqual(b, e);
CheckNotEqual(b, f);
CheckNotEqual(c, d);
CheckNotEqual(c, e);
CheckNotEqual(c, f);
CheckNotEqual(d, e);
CheckNotEqual(d, f);
CheckNotEqual(e, f);
}
/// <summary>
/// Asserts that the given protos are equal and have the same hash code.
/// </summary>
private static void CheckEqualsIsConsistent(IMessage message) {
// Object should be equal to itself.
Assert.AreEqual(message, message);
// Object should be equal to a dynamic copy of itself.
DynamicMessage dynamic = DynamicMessage.CreateBuilder(message).Build();
Assert.AreEqual(message, dynamic);
Assert.AreEqual(dynamic, message);
Assert.AreEqual(dynamic.GetHashCode(), message.GetHashCode());
}
/// <summary>
/// Asserts that the given protos are not equal and have different hash codes.
/// </summary>
/// <remarks>
/// It's valid for non-equal objects to have the same hash code, so
/// this test is stricter than it needs to be. However, this should happen
/// relatively rarely. (If this test fails, it's probably still due to a bug.)
/// </remarks>
private static void CheckNotEqual(IMessage m1, IMessage m2) {
String equalsError = string.Format("{0} should not be equal to {1}", m1, m2);
Assert.IsFalse(m1.Equals(m2), equalsError);
Assert.IsFalse(m2.Equals(m1), equalsError);
Assert.IsFalse(m1.GetHashCode() == m2.GetHashCode(),
string.Format("{0} should have a different hash code from {1}", m1, m2));
}
/// <summary>
/// Extends AbstractMessage and wraps some other message object. The methods
/// of the Message interface which aren't explicitly implemented by
/// AbstractMessage are forwarded to the wrapped object. This allows us to
/// test that AbstractMessage's implementations work even if the wrapped
/// object does not use them.
/// </summary>
private class AbstractMessageWrapper : AbstractMessage<AbstractMessageWrapper, AbstractMessageWrapper.Builder> {
private readonly IMessage wrappedMessage;
public IMessage WrappedMessage {
get { return wrappedMessage; }
}
public AbstractMessageWrapper(IMessage wrappedMessage) {
this.wrappedMessage = wrappedMessage;
}
public override MessageDescriptor DescriptorForType {
get { return wrappedMessage.DescriptorForType; }
}
public override AbstractMessageWrapper DefaultInstanceForType {
get { return new AbstractMessageWrapper(wrappedMessage.WeakDefaultInstanceForType); }
}
public override IDictionary<FieldDescriptor, object> AllFields {
get { return wrappedMessage.AllFields; }
}
public override bool HasField(FieldDescriptor field) {
return wrappedMessage.HasField(field);
}
public override object this[FieldDescriptor field] {
get { return wrappedMessage[field]; }
}
public override object this[FieldDescriptor field, int index] {
get { return wrappedMessage[field, index]; }
}
public override int GetRepeatedFieldCount(FieldDescriptor field) {
return wrappedMessage.GetRepeatedFieldCount(field);
}
public override UnknownFieldSet UnknownFields {
get { return wrappedMessage.UnknownFields; }
}
public override Builder CreateBuilderForType() {
return new Builder(wrappedMessage.WeakCreateBuilderForType());
}
internal class Builder : AbstractBuilder<AbstractMessageWrapper, Builder> {
private readonly IBuilder wrappedBuilder;
protected override Builder ThisBuilder {
get { return this; }
}
internal Builder(IBuilder wrappedBuilder) {
this.wrappedBuilder = wrappedBuilder;
}
public override Builder MergeFrom(AbstractMessageWrapper other) {
wrappedBuilder.WeakMergeFrom(other.wrappedMessage);
return this;
}
public override bool IsInitialized {
get { return wrappedBuilder.IsInitialized; }
}
public override IDictionary<FieldDescriptor, object> AllFields {
get { return wrappedBuilder.AllFields; }
}
public override object this[FieldDescriptor field] {
get { return wrappedBuilder[field]; }
set { wrappedBuilder[field] = value; }
}
public override MessageDescriptor DescriptorForType {
get { return wrappedBuilder.DescriptorForType; }
}
public override int GetRepeatedFieldCount(FieldDescriptor field) {
return wrappedBuilder.GetRepeatedFieldCount(field);
}
public override object this[FieldDescriptor field, int index] {
get { return wrappedBuilder[field, index]; }
set { wrappedBuilder[field, index] = value; }
}
public override bool HasField(FieldDescriptor field) {
return wrappedBuilder.HasField(field);
}
public override UnknownFieldSet UnknownFields {
get { return wrappedBuilder.UnknownFields; }
set { wrappedBuilder.UnknownFields = value; }
}
public override AbstractMessageWrapper Build() {
return new AbstractMessageWrapper(wrappedBuilder.WeakBuild());
}
public override AbstractMessageWrapper BuildPartial() {
return new AbstractMessageWrapper(wrappedBuilder.WeakBuildPartial());
}
public override Builder Clone() {
return new Builder(wrappedBuilder.WeakClone());
}
public override AbstractMessageWrapper DefaultInstanceForType {
get { return new AbstractMessageWrapper(wrappedBuilder.WeakDefaultInstanceForType); }
}
public override Builder ClearField(FieldDescriptor field) {
wrappedBuilder.WeakClearField(field);
return this;
}
public override Builder AddRepeatedField(FieldDescriptor field, object value) {
wrappedBuilder.WeakAddRepeatedField(field, value);
return this;
}
public override IBuilder CreateBuilderForField(FieldDescriptor field) {
wrappedBuilder.CreateBuilderForField(field);
return this;
}
public override Builder MergeFrom(IMessage other) {
wrappedBuilder.WeakMergeFrom(other);
return this;
}
public override Builder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry) {
wrappedBuilder.WeakMergeFrom(input, extensionRegistry);
return this;
}
}
}
}
}

98
csharp/ProtocolBuffers.Test/ByteStringTest.cs
View file

@ -1,98 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.Text;
using NUnit.Framework;
namespace Google.ProtocolBuffers {
[TestFixture]
public class ByteStringTest {
[Test]
public void EmptyByteStringHasZeroSize() {
Assert.AreEqual(0, ByteString.Empty.Length);
}
[Test]
public void CopyFromStringWithExplicitEncoding() {
ByteString bs = ByteString.CopyFrom("AB", Encoding.Unicode);
Assert.AreEqual(4, bs.Length);
Assert.AreEqual(65, bs[0]);
Assert.AreEqual(0, bs[1]);
Assert.AreEqual(66, bs[2]);
Assert.AreEqual(0, bs[3]);
}
[Test]
public void IsEmptyWhenEmpty() {
Assert.IsTrue(ByteString.CopyFromUtf8("").IsEmpty);
}
[Test]
public void IsEmptyWhenNotEmpty() {
Assert.IsFalse(ByteString.CopyFromUtf8("X").IsEmpty);
}
[Test]
public void CopyFromByteArrayCopiesContents() {
byte[] data = new byte[1];
data[0] = 10;
ByteString bs = ByteString.CopyFrom(data);
Assert.AreEqual(10, bs[0]);
data[0] = 5;
Assert.AreEqual(10, bs[0]);
}
[Test]
public void ToByteArrayCopiesContents() {
ByteString bs = ByteString.CopyFromUtf8("Hello");
byte[] data = bs.ToByteArray();
Assert.AreEqual('H', data[0]);
Assert.AreEqual('H', bs[0]);
data[0] = 0;
Assert.AreEqual(0, data[0]);
Assert.AreEqual('H', bs[0]);
}
[Test]
public void CopyFromUtf8UsesUtf8() {
ByteString bs = ByteString.CopyFromUtf8("\u20ac");
Assert.AreEqual(3, bs.Length);
Assert.AreEqual(0xe2, bs[0]);
Assert.AreEqual(0x82, bs[1]);
Assert.AreEqual(0xac, bs[2]);
}
[Test]
public void CopyFromPortion() {
byte[] data = new byte[]{0, 1, 2, 3, 4, 5, 6};
ByteString bs = ByteString.CopyFrom(data, 2, 3);
Assert.AreEqual(3, bs.Length);
Assert.AreEqual(2, bs[0]);
Assert.AreEqual(3, bs[1]);
}
[Test]
public void ToStringUtf8() {
ByteString bs = ByteString.CopyFromUtf8("\u20ac");
Assert.AreEqual("\u20ac", bs.ToStringUtf8());
}
[Test]
public void ToStringWithExplicitEncoding() {
ByteString bs = ByteString.CopyFrom("\u20ac", Encoding.Unicode);
Assert.AreEqual("\u20ac", bs.ToString(Encoding.Unicode));
}
}
}

376
csharp/ProtocolBuffers.Test/CodedInputStreamTest.cs
View file

@ -1,376 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.IO;
using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework;
using System.Diagnostics;
namespace Google.ProtocolBuffers {
[TestFixture]
public class CodedInputStreamTest {
/// <summary>
/// Helper to construct a byte array from a bunch of bytes. The inputs are
/// actually ints so that I can use hex notation and not get stupid errors
/// about precision.
/// </summary>
private static byte[] Bytes(params int[] bytesAsInts) {
byte[] bytes = new byte[bytesAsInts.Length];
for (int i = 0; i < bytesAsInts.Length; i++) {
bytes[i] = (byte)bytesAsInts[i];
}
return bytes;
}
/// <summary>
/// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and
/// </summary>
private static void AssertReadVarint(byte[] data, ulong value) {
CodedInputStream input = CodedInputStream.CreateInstance(data);
Assert.AreEqual((uint)value, input.ReadRawVarint32());
input = CodedInputStream.CreateInstance(data);
Assert.AreEqual(value, input.ReadRawVarint64());
// Try different block sizes.
for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) {
input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize));
Assert.AreEqual((uint)value, input.ReadRawVarint32());
input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize));
Assert.AreEqual(value, input.ReadRawVarint64());
}
}
/// <summary>
/// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and
/// expects them to fail with an InvalidProtocolBufferException whose
/// description matches the given one.
/// </summary>
private void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data) {
CodedInputStream input = CodedInputStream.CreateInstance(data);
try {
input.ReadRawVarint32();
Assert.Fail("Should have thrown an exception.");
} catch (InvalidProtocolBufferException e) {
Assert.AreEqual(expected.Message, e.Message);
}
input = CodedInputStream.CreateInstance(data);
try {
input.ReadRawVarint64();
Assert.Fail("Should have thrown an exception.");
} catch (InvalidProtocolBufferException e) {
Assert.AreEqual(expected.Message, e.Message);
}
}
[Test]
public void ReadVarint() {
AssertReadVarint(Bytes(0x00), 0);
AssertReadVarint(Bytes(0x01), 1);
AssertReadVarint(Bytes(0x7f), 127);
// 14882
AssertReadVarint(Bytes(0xa2, 0x74), (0x22 << 0) | (0x74 << 7));
// 2961488830
AssertReadVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b),
(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
(0x0bL << 28));
// 64-bit
// 7256456126
AssertReadVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b),
(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
(0x1bL << 28));
// 41256202580718336
AssertReadVarint(Bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49),
(0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) |
(0x43L << 28) | (0x49L << 35) | (0x24L << 42) | (0x49L << 49));
// 11964378330978735131
AssertReadVarint(Bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01),
(0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) |
(0x3bUL << 28) | (0x56UL << 35) | (0x00UL << 42) |
(0x05UL << 49) | (0x26UL << 56) | (0x01UL << 63));
// Failures
AssertReadVarintFailure(
InvalidProtocolBufferException.MalformedVarint(),
Bytes(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
0x00));
AssertReadVarintFailure(
InvalidProtocolBufferException.TruncatedMessage(),
Bytes(0x80));
}
/// <summary>
/// Parses the given bytes using ReadRawLittleEndian32() and checks
/// that the result matches the given value.
/// </summary>
private static void AssertReadLittleEndian32(byte[] data, uint value) {
CodedInputStream input = CodedInputStream.CreateInstance(data);
Assert.AreEqual(value, input.ReadRawLittleEndian32());
// Try different block sizes.
for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
input = CodedInputStream.CreateInstance(
new SmallBlockInputStream(data, blockSize));
Assert.AreEqual(value, input.ReadRawLittleEndian32());
}
}
/// <summary>
/// Parses the given bytes using ReadRawLittleEndian64() and checks
/// that the result matches the given value.
/// </summary>
private static void AssertReadLittleEndian64(byte[] data, ulong value) {
CodedInputStream input = CodedInputStream.CreateInstance(data);
Assert.AreEqual(value, input.ReadRawLittleEndian64());
// Try different block sizes.
for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
input = CodedInputStream.CreateInstance(
new SmallBlockInputStream(data, blockSize));
Assert.AreEqual(value, input.ReadRawLittleEndian64());
}
}
[Test]
public void ReadLittleEndian() {
AssertReadLittleEndian32(Bytes(0x78, 0x56, 0x34, 0x12), 0x12345678);
AssertReadLittleEndian32(Bytes(0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef0);
AssertReadLittleEndian64(Bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12),
0x123456789abcdef0L);
AssertReadLittleEndian64(
Bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef012345678UL);
}
[Test]
public void DecodeZigZag32() {
Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(0));
Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(1));
Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(2));
Assert.AreEqual(-2, CodedInputStream.DecodeZigZag32(3));
Assert.AreEqual(0x3FFFFFFF, CodedInputStream.DecodeZigZag32(0x7FFFFFFE));
Assert.AreEqual(unchecked((int)0xC0000000), CodedInputStream.DecodeZigZag32(0x7FFFFFFF));
Assert.AreEqual(0x7FFFFFFF, CodedInputStream.DecodeZigZag32(0xFFFFFFFE));
Assert.AreEqual(unchecked((int)0x80000000), CodedInputStream.DecodeZigZag32(0xFFFFFFFF));
}
[Test]
public void DecodeZigZag64() {
Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(0));
Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(1));
Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(2));
Assert.AreEqual(-2, CodedInputStream.DecodeZigZag64(3));
Assert.AreEqual(0x000000003FFFFFFFL, CodedInputStream.DecodeZigZag64(0x000000007FFFFFFEL));
Assert.AreEqual(unchecked((long)0xFFFFFFFFC0000000L), CodedInputStream.DecodeZigZag64(0x000000007FFFFFFFL));
Assert.AreEqual(0x000000007FFFFFFFL, CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFEL));
Assert.AreEqual(unchecked((long)0xFFFFFFFF80000000L), CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFFL));
Assert.AreEqual(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL));
Assert.AreEqual(unchecked((long)0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL));
}
[Test]
public void ReadWholeMessage() {
TestAllTypes message = TestUtil.GetAllSet();
byte[] rawBytes = message.ToByteArray();
Assert.AreEqual(rawBytes.Length, message.SerializedSize);
TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes);
TestUtil.AssertAllFieldsSet(message2);
// Try different block sizes.
for (int blockSize = 1; blockSize < 256; blockSize *= 2) {
message2 = TestAllTypes.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize));
TestUtil.AssertAllFieldsSet(message2);
}
}
[Test]
public void SkipWholeMessage() {
TestAllTypes message = TestUtil.GetAllSet();
byte[] rawBytes = message.ToByteArray();
// Create two parallel inputs. Parse one as unknown fields while using
// skipField() to skip each field on the other. Expect the same tags.
CodedInputStream input1 = CodedInputStream.CreateInstance(rawBytes);
CodedInputStream input2 = CodedInputStream.CreateInstance(rawBytes);
UnknownFieldSet.Builder unknownFields = UnknownFieldSet.CreateBuilder();
while (true) {
uint tag = input1.ReadTag();
Assert.AreEqual(tag, input2.ReadTag());
if (tag == 0) {
break;
}
unknownFields.MergeFieldFrom(tag, input1);
input2.SkipField(tag);
}
}
public void ReadHugeBlob() {
// Allocate and initialize a 1MB blob.
byte[] blob = new byte[1 << 20];
for (int i = 0; i < blob.Length; i++) {
blob[i] = (byte)i;
}
// Make a message containing it.
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TestUtil.SetAllFields(builder);
builder.SetOptionalBytes(ByteString.CopyFrom(blob));
TestAllTypes message = builder.Build();
// Serialize and parse it. Make sure to parse from an InputStream, not
// directly from a ByteString, so that CodedInputStream uses buffered
// reading.
TestAllTypes message2 = TestAllTypes.ParseFrom(message.ToByteString().CreateCodedInput());
Assert.AreEqual(message.OptionalBytes, message2.OptionalBytes);
// Make sure all the other fields were parsed correctly.
TestAllTypes message3 = TestAllTypes.CreateBuilder(message2)
.SetOptionalBytes(TestUtil.GetAllSet().OptionalBytes)
.Build();
TestUtil.AssertAllFieldsSet(message3);
}
[Test]
public void ReadMaliciouslyLargeBlob() {
MemoryStream ms = new MemoryStream();
CodedOutputStream output = CodedOutputStream.CreateInstance(ms);
uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited);
output.WriteRawVarint32(tag);
output.WriteRawVarint32(0x7FFFFFFF);
output.WriteRawBytes(new byte[32]); // Pad with a few random bytes.
output.Flush();
ms.Position = 0;
CodedInputStream input = CodedInputStream.CreateInstance(ms);
Assert.AreEqual(tag, input.ReadTag());
try {
input.ReadBytes();
Assert.Fail("Should have thrown an exception!");
} catch (InvalidProtocolBufferException) {
// success.
}
}
private static TestRecursiveMessage MakeRecursiveMessage(int depth) {
if (depth == 0) {
return TestRecursiveMessage.CreateBuilder().SetI(5).Build();
} else {
return TestRecursiveMessage.CreateBuilder()
.SetA(MakeRecursiveMessage(depth - 1)).Build();
}
}
private static void AssertMessageDepth(TestRecursiveMessage message, int depth) {
if (depth == 0) {
Assert.IsFalse(message.HasA);
Assert.AreEqual(5, message.I);
} else {
Assert.IsTrue(message.HasA);
AssertMessageDepth(message.A, depth - 1);
}
}
[Test]
public void MaliciousRecursion() {
ByteString data64 = MakeRecursiveMessage(64).ToByteString();
ByteString data65 = MakeRecursiveMessage(65).ToByteString();
AssertMessageDepth(TestRecursiveMessage.ParseFrom(data64), 64);
try {
TestRecursiveMessage.ParseFrom(data65);
Assert.Fail("Should have thrown an exception!");
} catch (InvalidProtocolBufferException) {
// success.
}
CodedInputStream input = data64.CreateCodedInput();
input.SetRecursionLimit(8);
try {
TestRecursiveMessage.ParseFrom(input);
Assert.Fail("Should have thrown an exception!");
} catch (InvalidProtocolBufferException) {
// success.
}
}
[Test]
public void SizeLimit() {
// Have to use a Stream rather than ByteString.CreateCodedInput as SizeLimit doesn't
// apply to the latter case.
MemoryStream ms = new MemoryStream(TestUtil.GetAllSet().ToByteString().ToByteArray());
CodedInputStream input = CodedInputStream.CreateInstance(ms);
input.SetSizeLimit(16);
try {
TestAllTypes.ParseFrom(input);
Assert.Fail("Should have thrown an exception!");
} catch (InvalidProtocolBufferException) {
// success.
}
}
/// <summary>
/// Tests that if we read an string that contains invalid UTF-8, no exception
/// is thrown. Instead, the invalid bytes are replaced with the Unicode
/// "replacement character" U+FFFD.
/// </summary>
[Test]
public void ReadInvalidUtf8() {
MemoryStream ms = new MemoryStream();
CodedOutputStream output = CodedOutputStream.CreateInstance(ms);
uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited);
output.WriteRawVarint32(tag);
output.WriteRawVarint32(1);
output.WriteRawBytes(new byte[] { 0x80 });
output.Flush();
ms.Position = 0;
CodedInputStream input = CodedInputStream.CreateInstance(ms);
Assert.AreEqual(tag, input.ReadTag());
string text = input.ReadString();
Assert.AreEqual('\ufffd', text[0]);
}
/// <summary>
/// A stream which limits the number of bytes it reads at a time.
/// We use this to make sure that CodedInputStream doesn't screw up when
/// reading in small blocks.
/// </summary>
private sealed class SmallBlockInputStream : MemoryStream {
private readonly int blockSize;
public SmallBlockInputStream(byte[] data, int blockSize)
: base(data) {
this.blockSize = blockSize;
}
public override int Read(byte[] buffer, int offset, int count) {
return base.Read(buffer, offset, Math.Min(count, blockSize));
}
}
}
}

239
csharp/ProtocolBuffers.Test/CodedOutputStreamTest.cs
View file

@ -1,239 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.IO;
using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework;
namespace Google.ProtocolBuffers {
[TestFixture]
public class CodedOutputStreamTest {
/// <summary>
/// Writes the given value using WriteRawVarint32() and WriteRawVarint64() and
/// checks that the result matches the given bytes
/// </summary>
private static void AssertWriteVarint(byte[] data, ulong value) {
// Only do 32-bit write if the value fits in 32 bits.
if ((value >> 32) == 0) {
MemoryStream rawOutput = new MemoryStream();
CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
output.WriteRawVarint32((uint) value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
// Also try computing size.
Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value));
}
{
MemoryStream rawOutput = new MemoryStream();
CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
output.WriteRawVarint64(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
// Also try computing size.
Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value));
}
// Try different buffer sizes.
for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) {
// Only do 32-bit write if the value fits in 32 bits.
if ((value >> 32) == 0) {
MemoryStream rawOutput = new MemoryStream();
CodedOutputStream output =
CodedOutputStream.CreateInstance(rawOutput, bufferSize);
output.WriteRawVarint32((uint) value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
}
{
MemoryStream rawOutput = new MemoryStream();
CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput, bufferSize);
output.WriteRawVarint64(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
}
}
}
/// <summary>
/// Tests WriteRawVarint32() and WriteRawVarint64()
/// </summary>
[Test]
public void WriteVarint() {
AssertWriteVarint(new byte[] {0x00}, 0);
AssertWriteVarint(new byte[] {0x01}, 1);
AssertWriteVarint(new byte[] {0x7f}, 127);
// 14882
AssertWriteVarint(new byte[] {0xa2, 0x74}, (0x22 << 0) | (0x74 << 7));
// 2961488830
AssertWriteVarint(new byte[] {0xbe, 0xf7, 0x92, 0x84, 0x0b},
(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
(0x0bL << 28));
// 64-bit
// 7256456126
AssertWriteVarint(new byte[] {0xbe, 0xf7, 0x92, 0x84, 0x1b},
(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) |
(0x1bL << 28));
// 41256202580718336
AssertWriteVarint(
new byte[] {0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49},
(0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) |
(0x43UL << 28) | (0x49L << 35) | (0x24UL << 42) | (0x49UL << 49));
// 11964378330978735131
AssertWriteVarint(
new byte[] {0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01},
unchecked((ulong)
((0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) |
(0x3bL << 28) | (0x56L << 35) | (0x00L << 42) |
(0x05L << 49) | (0x26L << 56) | (0x01L << 63))));
}
/// <summary>
/// Parses the given bytes using WriteRawLittleEndian32() and checks
/// that the result matches the given value.
/// </summary>
private static void AssertWriteLittleEndian32(byte[] data, uint value) {
MemoryStream rawOutput = new MemoryStream();
CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
output.WriteRawLittleEndian32(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
// Try different buffer sizes.
for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) {
rawOutput = new MemoryStream();
output = CodedOutputStream.CreateInstance(rawOutput, bufferSize);
output.WriteRawLittleEndian32(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
}
}
/// <summary>
/// Parses the given bytes using WriteRawLittleEndian64() and checks
/// that the result matches the given value.
/// </summary>
private static void AssertWriteLittleEndian64(byte[] data, ulong value) {
MemoryStream rawOutput = new MemoryStream();
CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput);
output.WriteRawLittleEndian64(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
// Try different block sizes.
for (int blockSize = 1; blockSize <= 16; blockSize *= 2) {
rawOutput = new MemoryStream();
output = CodedOutputStream.CreateInstance(rawOutput, blockSize);
output.WriteRawLittleEndian64(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
}
}
/// <summary>
/// Tests writeRawLittleEndian32() and writeRawLittleEndian64().
/// </summary>
[Test]
public void WriteLittleEndian() {
AssertWriteLittleEndian32(new byte[] {0x78, 0x56, 0x34, 0x12}, 0x12345678);
AssertWriteLittleEndian32(new byte[] {0xf0, 0xde, 0xbc, 0x9a}, 0x9abcdef0);
AssertWriteLittleEndian64(
new byte[]{0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12},
0x123456789abcdef0L);
AssertWriteLittleEndian64(
new byte[]{0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a},
0x9abcdef012345678UL);
}
[Test]
public void WriteWholeMessage() {
TestAllTypes message = TestUtil.GetAllSet();
byte[] rawBytes = message.ToByteArray();
TestUtil.AssertEqualBytes(TestUtil.GoldenMessage.ToByteArray(), rawBytes);
// Try different block sizes.
for (int blockSize = 1; blockSize < 256; blockSize *= 2) {
MemoryStream rawOutput = new MemoryStream();
CodedOutputStream output =
CodedOutputStream.CreateInstance(rawOutput, blockSize);
message.WriteTo(output);
output.Flush();
TestUtil.AssertEqualBytes(rawBytes, rawOutput.ToArray());
}
}
[Test]
public void EncodeZigZag32() {
Assert.AreEqual(0, CodedOutputStream.EncodeZigZag32( 0));
Assert.AreEqual(1, CodedOutputStream.EncodeZigZag32(-1));
Assert.AreEqual(2, CodedOutputStream.EncodeZigZag32( 1));
Assert.AreEqual(3, CodedOutputStream.EncodeZigZag32(-2));
Assert.AreEqual(0x7FFFFFFE, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF));
Assert.AreEqual(0x7FFFFFFF, CodedOutputStream.EncodeZigZag32(unchecked((int)0xC0000000)));
Assert.AreEqual(0xFFFFFFFE, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF));
Assert.AreEqual(0xFFFFFFFF, CodedOutputStream.EncodeZigZag32(unchecked((int)0x80000000)));
}
[Test]
public void EncodeZigZag64() {
Assert.AreEqual(0, CodedOutputStream.EncodeZigZag64( 0));
Assert.AreEqual(1, CodedOutputStream.EncodeZigZag64(-1));
Assert.AreEqual(2, CodedOutputStream.EncodeZigZag64( 1));
Assert.AreEqual(3, CodedOutputStream.EncodeZigZag64(-2));
Assert.AreEqual(0x000000007FFFFFFEL,
CodedOutputStream.EncodeZigZag64(unchecked((long)0x000000003FFFFFFFUL)));
Assert.AreEqual(0x000000007FFFFFFFL,
CodedOutputStream.EncodeZigZag64(unchecked((long)0xFFFFFFFFC0000000UL)));
Assert.AreEqual(0x00000000FFFFFFFEL,
CodedOutputStream.EncodeZigZag64(unchecked((long)0x000000007FFFFFFFUL)));
Assert.AreEqual(0x00000000FFFFFFFFL,
CodedOutputStream.EncodeZigZag64(unchecked((long)0xFFFFFFFF80000000UL)));
Assert.AreEqual(0xFFFFFFFFFFFFFFFEL,
CodedOutputStream.EncodeZigZag64(unchecked((long)0x7FFFFFFFFFFFFFFFUL)));
Assert.AreEqual(0xFFFFFFFFFFFFFFFFL,
CodedOutputStream.EncodeZigZag64(unchecked((long)0x8000000000000000UL)));
}
[Test]
public void RoundTripZigZag32() {
// Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1)
// were chosen semi-randomly via keyboard bashing.
Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0)));
Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1)));
Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1)));
Assert.AreEqual(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927)));
Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612)));
}
[Test]
public void RoundTripZigZag64() {
Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0)));
Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1)));
Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1)));
Assert.AreEqual(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927)));
Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612)));
Assert.AreEqual(856912304801416L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L)));
Assert.AreEqual(-75123905439571256L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L)));
}
}
}

64
csharp/ProtocolBuffers.Test/Collections/PopsicleListTest.cs
View file

@ -1,64 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
namespace Google.ProtocolBuffers.Collections {
[TestFixture]
public class PopsicleListTest {
[Test]
public void MutatingOperationsOnFrozenList() {
PopsicleList<string> list = new PopsicleList<string>();
list.MakeReadOnly();
AssertNotSupported(() => list.Add(""));
AssertNotSupported(() => list.Clear());
AssertNotSupported(() => list.Insert(0, ""));
AssertNotSupported(() => list.Remove(""));
AssertNotSupported(() => list.RemoveAt(0));
}
[Test]
public void NonMutatingOperationsOnFrozenList() {
PopsicleList<string> list = new PopsicleList<string>();
list.MakeReadOnly();
Assert.IsFalse(list.Contains(""));
Assert.AreEqual(0, list.Count);
list.CopyTo(new string[5], 0);
list.GetEnumerator();
Assert.AreEqual(-1, list.IndexOf(""));
Assert.IsTrue(list.IsReadOnly);
}
[Test]
public void MutatingOperationsOnFluidList() {
PopsicleList<string> list = new PopsicleList<string>();
list.Add("");
list.Clear();
list.Insert(0, "");
list.Remove("");
list.Add("x"); // Just to make the next call valid
list.RemoveAt(0);
}
[Test]
public void NonMutatingOperationsOnFluidList() {
PopsicleList<string> list = new PopsicleList<string>();
Assert.IsFalse(list.Contains(""));
Assert.AreEqual(0, list.Count);
list.CopyTo(new string[5], 0);
list.GetEnumerator();
Assert.AreEqual(-1, list.IndexOf(""));
Assert.IsFalse(list.IsReadOnly);
}
private static void AssertNotSupported(Action action) {
try {
action();
Assert.Fail("Expected NotSupportedException");
} catch (NotSupportedException) {
// Expected
}
}
}
}

273
csharp/ProtocolBuffers.Test/DescriptorsTest.cs
View file

@ -1,273 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.TestProtos;
namespace Google.ProtocolBuffers {
/// <summary>
/// Tests for descriptors. (Not in its own namespace or broken up into individual classes as the
/// size doesn't warrant it. On the other hand, this makes me feel a bit dirty...)
/// </summary>
[TestFixture]
public class DescriptorsTest {
[Test]
public void FileDescriptor() {
FileDescriptor file = UnitTestProtoFile.Descriptor;
Assert.AreEqual("google/protobuf/unittest.proto", file.Name);
Assert.AreEqual("protobuf_unittest", file.Package);
Assert.AreEqual("UnittestProto", file.Options.JavaOuterClassname);
Assert.AreEqual("google/protobuf/unittest.proto", file.Proto.Name);
Assert.AreEqual(1, file.Dependencies.Count);
Assert.AreEqual(UnitTestImportProtoFile.Descriptor, file.Dependencies[0]);
MessageDescriptor messageType = TestAllTypes.Descriptor;
Assert.AreEqual(messageType, file.MessageTypes[0]);
Assert.AreEqual(messageType, file.FindTypeByName<MessageDescriptor>("TestAllTypes"));
Assert.IsNull(file.FindTypeByName<MessageDescriptor>("NoSuchType"));
Assert.IsNull(file.FindTypeByName<MessageDescriptor>("protobuf_unittest.TestAllTypes"));
for (int i = 0; i < file.MessageTypes.Count; i++) {
Assert.AreEqual(i, file.MessageTypes[i].Index);
}
Assert.AreEqual(file.EnumTypes[0], file.FindTypeByName<EnumDescriptor>("ForeignEnum"));
Assert.IsNull(file.FindTypeByName<EnumDescriptor>("NoSuchType"));
Assert.IsNull(file.FindTypeByName<EnumDescriptor>("protobuf_unittest.ForeignEnum"));
Assert.AreEqual(1, UnitTestImportProtoFile.Descriptor.EnumTypes.Count);
Assert.AreEqual("ImportEnum", UnitTestImportProtoFile.Descriptor.EnumTypes[0].Name);
for (int i = 0; i < file.EnumTypes.Count; i++) {
Assert.AreEqual(i, file.EnumTypes[i].Index);
}
ServiceDescriptor service = TestService.Descriptor;
Assert.AreEqual(service, file.Services[0]);
Assert.AreEqual(service, file.FindTypeByName<ServiceDescriptor>("TestService"));
Assert.IsNull(file.FindTypeByName<ServiceDescriptor>("NoSuchType"));
Assert.IsNull(file.FindTypeByName<ServiceDescriptor>("protobuf_unittest.TestService"));
Assert.AreEqual(0, UnitTestImportProtoFile.Descriptor.Services.Count);
for (int i = 0; i < file.Services.Count; i++) {
Assert.AreEqual(i, file.Services[i].Index);
}
FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor;
Assert.AreEqual(extension, file.Extensions[0]);
Assert.AreEqual(extension, file.FindTypeByName<FieldDescriptor>("optional_int32_extension"));
Assert.IsNull(file.FindTypeByName<FieldDescriptor>("no_such_ext"));
Assert.IsNull(file.FindTypeByName<FieldDescriptor>("protobuf_unittest.optional_int32_extension"));
Assert.AreEqual(0, UnitTestImportProtoFile.Descriptor.Extensions.Count);
for (int i = 0; i < file.Extensions.Count; i++) {
Assert.AreEqual(i, file.Extensions[i].Index);
}
}
[Test]
public void MessageDescriptor() {
MessageDescriptor messageType = TestAllTypes.Descriptor;
MessageDescriptor nestedType = TestAllTypes.Types.NestedMessage.Descriptor;
Assert.AreEqual("TestAllTypes", messageType.Name);
Assert.AreEqual("protobuf_unittest.TestAllTypes", messageType.FullName);
Assert.AreEqual(UnitTestProtoFile.Descriptor, messageType.File);
Assert.IsNull(messageType.ContainingType);
Assert.AreEqual(DescriptorProtos.MessageOptions.DefaultInstance, messageType.Options);
Assert.AreEqual("TestAllTypes", messageType.Proto.Name);
Assert.AreEqual("NestedMessage", nestedType.Name);
Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedMessage", nestedType.FullName);
Assert.AreEqual(UnitTestProtoFile.Descriptor, nestedType.File);
Assert.AreEqual(messageType, nestedType.ContainingType);
FieldDescriptor field = messageType.Fields[0];
Assert.AreEqual("optional_int32", field.Name);
Assert.AreEqual(field, messageType.FindDescriptor<FieldDescriptor>("optional_int32"));
Assert.IsNull(messageType.FindDescriptor<FieldDescriptor>("no_such_field"));
Assert.AreEqual(field, messageType.FindFieldByNumber(1));
Assert.IsNull(messageType.FindFieldByNumber(571283));
for (int i = 0; i < messageType.Fields.Count; i++) {
Assert.AreEqual(i, messageType.Fields[i].Index);
}
Assert.AreEqual(nestedType, messageType.NestedTypes[0]);
Assert.AreEqual(nestedType, messageType.FindDescriptor<MessageDescriptor>("NestedMessage"));
Assert.IsNull(messageType.FindDescriptor<MessageDescriptor>("NoSuchType"));
for (int i = 0; i < messageType.NestedTypes.Count; i++) {
Assert.AreEqual(i, messageType.NestedTypes[i].Index);
}
Assert.AreEqual(messageType.EnumTypes[0], messageType.FindDescriptor<EnumDescriptor>("NestedEnum"));
Assert.IsNull(messageType.FindDescriptor<EnumDescriptor>("NoSuchType"));
for (int i = 0; i < messageType.EnumTypes.Count; i++) {
Assert.AreEqual(i, messageType.EnumTypes[i].Index);
}
}
[Test]
public void FieldDescriptor() {
MessageDescriptor messageType = TestAllTypes.Descriptor;
FieldDescriptor primitiveField = messageType.FindDescriptor<FieldDescriptor>("optional_int32");
FieldDescriptor enumField = messageType.FindDescriptor<FieldDescriptor>("optional_nested_enum");
FieldDescriptor messageField = messageType.FindDescriptor<FieldDescriptor>("optional_foreign_message");
FieldDescriptor cordField = messageType.FindDescriptor<FieldDescriptor>("optional_cord");
FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor;
FieldDescriptor nestedExtension = TestRequired.Single.Descriptor;
Assert.AreEqual("optional_int32", primitiveField.Name);
Assert.AreEqual("protobuf_unittest.TestAllTypes.optional_int32",
primitiveField.FullName);
Assert.AreEqual(1, primitiveField.FieldNumber);
Assert.AreEqual(messageType, primitiveField.ContainingType);
Assert.AreEqual(UnitTestProtoFile.Descriptor, primitiveField.File);
Assert.AreEqual(FieldType.Int32, primitiveField.FieldType);
Assert.AreEqual(MappedType.Int32, primitiveField.MappedType);
Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance, primitiveField.Options);
Assert.IsFalse(primitiveField.IsExtension);
Assert.AreEqual("optional_int32", primitiveField.Proto.Name);
Assert.AreEqual("optional_nested_enum", enumField.Name);
Assert.AreEqual(FieldType.Enum, enumField.FieldType);
Assert.AreEqual(MappedType.Enum, enumField.MappedType);
// Assert.AreEqual(TestAllTypes.Types.NestedEnum.Descriptor, enumField.EnumType);
Assert.AreEqual("optional_foreign_message", messageField.Name);
Assert.AreEqual(FieldType.Message, messageField.FieldType);
Assert.AreEqual(MappedType.Message, messageField.MappedType);
Assert.AreEqual(ForeignMessage.Descriptor, messageField.MessageType);
Assert.AreEqual("optional_cord", cordField.Name);
Assert.AreEqual(FieldType.String, cordField.FieldType);
Assert.AreEqual(MappedType.String, cordField.MappedType);
Assert.AreEqual(DescriptorProtos.FieldOptions.Types.CType.CORD, cordField.Options.Ctype);
Assert.AreEqual("optional_int32_extension", extension.Name);
Assert.AreEqual("protobuf_unittest.optional_int32_extension", extension.FullName);
Assert.AreEqual(1, extension.FieldNumber);
Assert.AreEqual(TestAllExtensions.Descriptor, extension.ContainingType);
Assert.AreEqual(UnitTestProtoFile.Descriptor, extension.File);
Assert.AreEqual(FieldType.Int32, extension.FieldType);
Assert.AreEqual(MappedType.Int32, extension.MappedType);
Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance,
extension.Options);
Assert.IsTrue(extension.IsExtension);
Assert.AreEqual(null, extension.ExtensionScope);
Assert.AreEqual("optional_int32_extension", extension.Proto.Name);
Assert.AreEqual("single", nestedExtension.Name);
Assert.AreEqual("protobuf_unittest.TestRequired.single",
nestedExtension.FullName);
Assert.AreEqual(TestRequired.Descriptor,
nestedExtension.ExtensionScope);
}
[Test]
public void FieldDescriptorLabel() {
FieldDescriptor requiredField =
TestRequired.Descriptor.FindDescriptor<FieldDescriptor>("a");
FieldDescriptor optionalField =
TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("optional_int32");
FieldDescriptor repeatedField =
TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("repeated_int32");
Assert.IsTrue(requiredField.IsRequired);
Assert.IsFalse(requiredField.IsRepeated);
Assert.IsFalse(optionalField.IsRequired);
Assert.IsFalse(optionalField.IsRepeated);
Assert.IsFalse(repeatedField.IsRequired);
Assert.IsTrue(repeatedField.IsRepeated);
}
[Test]
public void FieldDescriptorDefault() {
MessageDescriptor d = TestAllTypes.Descriptor;
Assert.IsFalse(d.FindDescriptor<FieldDescriptor>("optional_int32").HasDefaultValue);
Assert.AreEqual(0, d.FindDescriptor<FieldDescriptor>("optional_int32").DefaultValue);
Assert.IsTrue(d.FindDescriptor<FieldDescriptor>("default_int32").HasDefaultValue);
Assert.AreEqual(41, d.FindDescriptor<FieldDescriptor>("default_int32").DefaultValue);
d = TestExtremeDefaultValues.Descriptor;
Assert.AreEqual(ByteString.CopyFrom("\u0000\u0001\u0007\b\f\n\r\t\u000b\\\'\"\u00fe", Encoding.GetEncoding(28591)),
d.FindDescriptor<FieldDescriptor>("escaped_bytes").DefaultValue);
Assert.AreEqual(uint.MaxValue, d.FindDescriptor<FieldDescriptor>("large_uint32").DefaultValue);
Assert.AreEqual(ulong.MaxValue, d.FindDescriptor<FieldDescriptor>("large_uint64").DefaultValue);
}
[Test]
public void EnumDescriptor() {
// Note: this test is a bit different to the Java version because there's no static way of getting to the descriptor
EnumDescriptor enumType = UnitTestProtoFile.Descriptor.FindTypeByName<EnumDescriptor>("ForeignEnum");
EnumDescriptor nestedType = TestAllTypes.Descriptor.FindDescriptor<EnumDescriptor>("NestedEnum");
Assert.AreEqual("ForeignEnum", enumType.Name);
Assert.AreEqual("protobuf_unittest.ForeignEnum", enumType.FullName);
Assert.AreEqual(UnitTestProtoFile.Descriptor, enumType.File);
Assert.IsNull(enumType.ContainingType);
Assert.AreEqual(DescriptorProtos.EnumOptions.DefaultInstance,
enumType.Options);
Assert.AreEqual("NestedEnum", nestedType.Name);
Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedEnum",
nestedType.FullName);
Assert.AreEqual(UnitTestProtoFile.Descriptor, nestedType.File);
Assert.AreEqual(TestAllTypes.Descriptor, nestedType.ContainingType);
EnumValueDescriptor value = enumType.FindValueByName("FOREIGN_FOO");
Assert.AreEqual(value, enumType.Values[0]);
Assert.AreEqual("FOREIGN_FOO", value.Name);
Assert.AreEqual(4, value.Number);
Assert.AreEqual((int) ForeignEnum.FOREIGN_FOO, value.Number);
Assert.AreEqual(value, enumType.FindValueByNumber(4));
Assert.IsNull(enumType.FindValueByName("NO_SUCH_VALUE"));
for (int i = 0; i < enumType.Values.Count; i++) {
Assert.AreEqual(i, enumType.Values[i].Index);
}
}
[Test]
public void ServiceDescriptor() {
ServiceDescriptor service = TestService.Descriptor;
Assert.AreEqual("TestService", service.Name);
Assert.AreEqual("protobuf_unittest.TestService", service.FullName);
Assert.AreEqual(UnitTestProtoFile.Descriptor, service.File);
Assert.AreEqual(2, service.Methods.Count);
MethodDescriptor fooMethod = service.Methods[0];
Assert.AreEqual("Foo", fooMethod.Name);
Assert.AreEqual(FooRequest.Descriptor, fooMethod.InputType);
Assert.AreEqual(FooResponse.Descriptor, fooMethod.OutputType);
Assert.AreEqual(fooMethod, service.FindMethodByName("Foo"));
MethodDescriptor barMethod = service.Methods[1];
Assert.AreEqual("Bar", barMethod.Name);
Assert.AreEqual(BarRequest.Descriptor, barMethod.InputType);
Assert.AreEqual(BarResponse.Descriptor, barMethod.OutputType);
Assert.AreEqual(barMethod, service.FindMethodByName("Bar"));
Assert.IsNull(service.FindMethodByName("NoSuchMethod"));
for (int i = 0; i < service.Methods.Count; i++) {
Assert.AreEqual(i, service.Methods[i].Index);
}
}
}
}

114
csharp/ProtocolBuffers.Test/DynamicMessageTest.cs
View file

@ -1,114 +0,0 @@
using Google.ProtocolBuffers.TestProtos;
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using NUnit.Framework;
namespace Google.ProtocolBuffers {
[TestFixture]
public class DynamicMessageTest {
private ReflectionTester reflectionTester;
private ReflectionTester extensionsReflectionTester;
[SetUp]
public void SetUp() {
reflectionTester = ReflectionTester.CreateTestAllTypesInstance();
extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance();
}
[Test]
public void DynamicMessageAccessors() {
IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
reflectionTester.SetAllFieldsViaReflection(builder);
IMessage message = builder.WeakBuild();
reflectionTester.AssertAllFieldsSetViaReflection(message);
}
[Test]
public void DynamicMessageExtensionAccessors() {
// We don't need to extensively test DynamicMessage's handling of
// extensions because, frankly, it doesn't do anything special with them.
// It treats them just like any other fields.
IBuilder builder = DynamicMessage.CreateBuilder(TestAllExtensions.Descriptor);
extensionsReflectionTester.SetAllFieldsViaReflection(builder);
IMessage message = builder.WeakBuild();
extensionsReflectionTester.AssertAllFieldsSetViaReflection(message);
}
[Test]
public void DynamicMessageRepeatedSetters() {
IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
reflectionTester.SetAllFieldsViaReflection(builder);
reflectionTester.ModifyRepeatedFieldsViaReflection(builder);
IMessage message = builder.WeakBuild();
reflectionTester.AssertRepeatedFieldsModifiedViaReflection(message);
}
[Test]
public void DynamicMessageDefaults() {
reflectionTester.AssertClearViaReflection(DynamicMessage.GetDefaultInstance(TestAllTypes.Descriptor));
reflectionTester.AssertClearViaReflection(DynamicMessage.CreateBuilder(TestAllTypes.Descriptor).Build());
}
[Test]
public void DynamicMessageSerializedSize() {
TestAllTypes message = TestUtil.GetAllSet();
IBuilder dynamicBuilder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
reflectionTester.SetAllFieldsViaReflection(dynamicBuilder);
IMessage dynamicMessage = dynamicBuilder.WeakBuild();
Assert.AreEqual(message.SerializedSize, dynamicMessage.SerializedSize);
}
[Test]
public void DynamicMessageSerialization() {
IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor);
reflectionTester.SetAllFieldsViaReflection(builder);
IMessage message = builder.WeakBuild();
ByteString rawBytes = message.ToByteString();
TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes);
TestUtil.AssertAllFieldsSet(message2);
// In fact, the serialized forms should be exactly the same, byte-for-byte.
Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), rawBytes);
}
[Test]
public void DynamicMessageParsing() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TestUtil.SetAllFields(builder);
TestAllTypes message = builder.Build();
ByteString rawBytes = message.ToByteString();
IMessage message2 = DynamicMessage.ParseFrom(TestAllTypes.Descriptor, rawBytes);
reflectionTester.AssertAllFieldsSetViaReflection(message2);
}
[Test]
public void DynamicMessageCopy() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TestUtil.SetAllFields(builder);
TestAllTypes message = builder.Build();
DynamicMessage copy = DynamicMessage.CreateBuilder(message).Build();
reflectionTester.AssertAllFieldsSetViaReflection(copy);
}
}
}

290
csharp/ProtocolBuffers.Test/GeneratedMessageTest.cs
View file

@ -1,290 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections.Generic;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework;
namespace Google.ProtocolBuffers {
[TestFixture]
public class GeneratedMessageTest {
ReflectionTester reflectionTester;
ReflectionTester extensionsReflectionTester;
[SetUp]
public void SetUp() {
reflectionTester = ReflectionTester.CreateTestAllTypesInstance();
extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance();
}
[Test]
public void RepeatedAddPrimitiveBeforeBuild() {
TestAllTypes message = new TestAllTypes.Builder { RepeatedInt32List = { 1, 2, 3 } }.Build();
TestUtil.AssertEqual(new int[]{1, 2, 3}, message.RepeatedInt32List);
}
[Test]
public void AddPrimitiveFailsAfterBuild() {
TestAllTypes.Builder builder = new TestAllTypes.Builder();
IList<int> list = builder.RepeatedInt32List;
list.Add(1); // Fine
builder.Build();
try {
list.Add(2);
Assert.Fail("List should be frozen");
} catch (NotSupportedException) {
// Expected
}
}
[Test]
public void RepeatedAddMessageBeforeBuild() {
TestAllTypes message = new TestAllTypes.Builder {
RepeatedNestedMessageList = { new TestAllTypes.Types.NestedMessage.Builder { Bb = 10 }.Build() } }.Build();
Assert.AreEqual(1, message.RepeatedNestedMessageCount);
Assert.AreEqual(10, message.RepeatedNestedMessageList[0].Bb);
}
[Test]
public void AddMessageFailsAfterBuild() {
TestAllTypes.Builder builder = new TestAllTypes.Builder();
IList<TestAllTypes.Types.NestedMessage> list = builder.RepeatedNestedMessageList;
builder.Build();
try {
list.Add(new TestAllTypes.Types.NestedMessage.Builder { Bb = 10 }.Build());
Assert.Fail("List should be frozen");
} catch (NotSupportedException) {
// Expected
}
}
[Test]
public void DefaultInstance() {
Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.DefaultInstance.DefaultInstanceForType);
Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().DefaultInstanceForType);
}
[Test]
public void Accessors() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TestUtil.SetAllFields(builder);
TestAllTypes message = builder.Build();
TestUtil.AssertAllFieldsSet(message);
}
[Test]
public void RepeatedSetters() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TestUtil.SetAllFields(builder);
TestUtil.ModifyRepeatedFields(builder);
TestAllTypes message = builder.Build();
TestUtil.AssertRepeatedFieldsModified(message);
}
[Test]
public void RepeatedAppend() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
builder.AddRangeRepeatedInt32(new int[]{1, 2, 3, 4});
builder.AddRangeRepeatedForeignEnum((new ForeignEnum[] { ForeignEnum.FOREIGN_BAZ }));
ForeignMessage foreignMessage = ForeignMessage.CreateBuilder().SetC(12).Build();
builder.AddRangeRepeatedForeignMessage(new ForeignMessage[] {foreignMessage});
TestAllTypes message = builder.Build();
TestUtil.AssertEqual(message.RepeatedInt32List, new int[]{1, 2, 3, 4});
TestUtil.AssertEqual(message.RepeatedForeignEnumList, new ForeignEnum[] {ForeignEnum.FOREIGN_BAZ});
Assert.AreEqual(1, message.RepeatedForeignMessageCount);
Assert.AreEqual(12, message.GetRepeatedForeignMessage(0).C);
}
[Test]
public void SettingForeignMessageUsingBuilder() {
TestAllTypes message = TestAllTypes.CreateBuilder()
// Pass builder for foreign message instance.
.SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(123))
.Build();
TestAllTypes expectedMessage = TestAllTypes.CreateBuilder()
// Create expected version passing foreign message instance explicitly.
.SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(123).Build())
.Build();
Assert.AreEqual(expectedMessage, message);
}
[Test]
public void SettingRepeatedForeignMessageUsingBuilder() {
TestAllTypes message = TestAllTypes.CreateBuilder()
// Pass builder for foreign message instance.
.AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(456))
.Build();
TestAllTypes expectedMessage = TestAllTypes.CreateBuilder()
// Create expected version passing foreign message instance explicitly.
.AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(456).Build())
.Build();
Assert.AreEqual(expectedMessage, message);
}
[Test]
public void Defaults() {
TestUtil.AssertClear(TestAllTypes.DefaultInstance);
TestUtil.AssertClear(TestAllTypes.CreateBuilder().Build());
Assert.AreEqual("\u1234", TestExtremeDefaultValues.DefaultInstance.Utf8String);
}
[Test]
public void ReflectionGetters() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TestUtil.SetAllFields(builder);
TestAllTypes message = builder.Build();
reflectionTester.AssertAllFieldsSetViaReflection(message);
}
[Test]
public void ReflectionSetters() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
reflectionTester.SetAllFieldsViaReflection(builder);
TestAllTypes message = builder.Build();
TestUtil.AssertAllFieldsSet(message);
}
[Test]
public void ReflectionRepeatedSetters() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
reflectionTester.SetAllFieldsViaReflection(builder);
reflectionTester.ModifyRepeatedFieldsViaReflection(builder);
TestAllTypes message = builder.Build();
TestUtil.AssertRepeatedFieldsModified(message);
}
[Test]
public void ReflectionDefaults() {
reflectionTester.AssertClearViaReflection(TestAllTypes.DefaultInstance);
reflectionTester.AssertClearViaReflection(TestAllTypes.CreateBuilder().Build());
}
// =================================================================
// Extensions.
[Test]
public void ExtensionAccessors() {
TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
TestUtil.SetAllExtensions(builder);
TestAllExtensions message = builder.Build();
TestUtil.AssertAllExtensionsSet(message);
}
[Test]
public void ExtensionRepeatedSetters() {
TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
TestUtil.SetAllExtensions(builder);
TestUtil.ModifyRepeatedExtensions(builder);
TestAllExtensions message = builder.Build();
TestUtil.AssertRepeatedExtensionsModified(message);
}
[Test]
public void ExtensionDefaults() {
TestUtil.AssertExtensionsClear(TestAllExtensions.DefaultInstance);
TestUtil.AssertExtensionsClear(TestAllExtensions.CreateBuilder().Build());
}
[Test]
public void ExtensionReflectionGetters() {
TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
TestUtil.SetAllExtensions(builder);
TestAllExtensions message = builder.Build();
extensionsReflectionTester.AssertAllFieldsSetViaReflection(message);
}
[Test]
public void ExtensionReflectionSetters() {
TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
extensionsReflectionTester.SetAllFieldsViaReflection(builder);
TestAllExtensions message = builder.Build();
TestUtil.AssertAllExtensionsSet(message);
}
[Test]
public void ExtensionReflectionRepeatedSetters() {
TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
extensionsReflectionTester.SetAllFieldsViaReflection(builder);
extensionsReflectionTester.ModifyRepeatedFieldsViaReflection(builder);
TestAllExtensions message = builder.Build();
TestUtil.AssertRepeatedExtensionsModified(message);
}
[Test]
public void ExtensionReflectionDefaults() {
extensionsReflectionTester.AssertClearViaReflection(TestAllExtensions.DefaultInstance);
extensionsReflectionTester.AssertClearViaReflection(TestAllExtensions.CreateBuilder().Build());
}
[Test]
public void ClearExtension() {
// ClearExtension() is not actually used in TestUtil, so try it manually.
Assert.IsFalse(TestAllExtensions.CreateBuilder()
.SetExtension(UnitTestProtoFile.OptionalInt32Extension, 1)
.ClearExtension(UnitTestProtoFile.OptionalInt32Extension)
.HasExtension(UnitTestProtoFile.OptionalInt32Extension));
Assert.AreEqual(0, TestAllExtensions.CreateBuilder()
.AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 1)
.ClearExtension(UnitTestProtoFile.RepeatedInt32Extension)
.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension));
}
[Test]
public void MultipleFilesOption() {
// We mostly just want to check that things compile.
MessageWithNoOuter message = MessageWithNoOuter.CreateBuilder()
.SetNested(MessageWithNoOuter.Types.NestedMessage.CreateBuilder().SetI(1))
.AddForeign(TestAllTypes.CreateBuilder().SetOptionalInt32(1))
.SetNestedEnum(MessageWithNoOuter.Types.NestedEnum.BAZ)
.SetForeignEnum(EnumWithNoOuter.BAR)
.Build();
Assert.AreEqual(message, MessageWithNoOuter.ParseFrom(message.ToByteString()));
Assert.AreEqual(MultiFileProto.Descriptor, MessageWithNoOuter.Descriptor.File);
FieldDescriptor field = MessageWithNoOuter.Descriptor.FindDescriptor<FieldDescriptor>("foreign_enum");
Assert.AreEqual(MultiFileProto.Descriptor.FindTypeByName<EnumDescriptor>("EnumWithNoOuter")
.FindValueByNumber((int)EnumWithNoOuter.BAR), message[field]);
Assert.AreEqual(MultiFileProto.Descriptor, ServiceWithNoOuter.Descriptor.File);
Assert.IsFalse(TestAllExtensions.DefaultInstance.HasExtension(MultiFileProto.ExtensionWithOuter));
}
[Test]
public void OptionalFieldWithRequiredSubfieldsOptimizedForSize() {
TestOptionalOptimizedForSize message = TestOptionalOptimizedForSize.DefaultInstance;
Assert.IsTrue(message.IsInitialized);
message = TestOptionalOptimizedForSize.CreateBuilder().SetO(
TestRequiredOptimizedForSize.CreateBuilder().BuildPartial()
).BuildPartial();
Assert.IsFalse(message.IsInitialized);
message = TestOptionalOptimizedForSize.CreateBuilder().SetO(
TestRequiredOptimizedForSize.CreateBuilder().SetX(5).BuildPartial()
).BuildPartial();
Assert.IsTrue(message.IsInitialized);
}
}
}

23
csharp/ProtocolBuffers.Test/MessageStreamIteratorTest.cs
View file

@ -1,23 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using System.IO;
using NUnit.Framework;
using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage;
namespace Google.ProtocolBuffers {
[TestFixture]
public class MessageStreamIteratorTest {
[Test]
public void ThreeMessagesInMemory() {
MemoryStream stream = new MemoryStream(MessageStreamWriterTest.ThreeMessageData);
IEnumerable<NestedMessage> iterator = MessageStreamIterator<NestedMessage>.FromStreamProvider(() => stream);
List<NestedMessage> messages = new List<NestedMessage>(iterator);
Assert.AreEqual(3, messages.Count);
Assert.AreEqual(5, messages[0].Bb);
Assert.AreEqual(1500, messages[1].Bb);
Assert.IsFalse(messages[2].HasBb);
}
}
}

36
csharp/ProtocolBuffers.Test/MessageStreamWriterTest.cs
View file

@ -1,36 +0,0 @@
using System.IO;
using NUnit.Framework;
using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage;
namespace Google.ProtocolBuffers {
[TestFixture]
public class MessageStreamWriterTest {
internal static readonly byte[] ThreeMessageData = new byte[] {
(1 << 3) | 2, 2, // Field 1, 2 bytes long (first message)
(1 << 3) | 0, 5, // Field 1, value 5
(1 << 3) | 2, 3, // Field 1, 3 bytes long (second message)
(1 << 3) | 0, (1500 & 0x7f) | 0x80, 1500 >> 7, // Field 1, value 1500
(1 << 3) | 2, 0, // Field 1, no data (third message)
};
[Test]
public void ThreeMessages() {
NestedMessage message1 = new NestedMessage.Builder { Bb = 5 }.Build();
NestedMessage message2 = new NestedMessage.Builder { Bb = 1500 }.Build();
NestedMessage message3 = new NestedMessage.Builder().Build();
byte[] data;
using (MemoryStream stream = new MemoryStream()) {
MessageStreamWriter<NestedMessage> writer = new MessageStreamWriter<NestedMessage>(stream);
writer.Write(message1);
writer.Write(message2);
writer.Write(message3);
writer.Flush();
data = stream.ToArray();
}
TestUtil.AssertEqualBytes(ThreeMessageData, data);
}
}
}

299
csharp/ProtocolBuffers.Test/MessageTest.cs
View file

@ -1,299 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework;
namespace Google.ProtocolBuffers {
/// <summary>
/// Miscellaneous tests for message operations that apply to both
/// generated and dynamic messages.
/// </summary>
[TestFixture]
public class MessageTest {
// =================================================================
// Message-merging tests.
private static readonly TestAllTypes MergeSource = new TestAllTypes.Builder {
OptionalInt32 = 1,
OptionalString = "foo",
OptionalForeignMessage = ForeignMessage.DefaultInstance,
}.AddRepeatedString("bar").Build();
private static readonly TestAllTypes MergeDest = new TestAllTypes.Builder {
OptionalInt64 = 2,
OptionalString = "baz",
OptionalForeignMessage = new ForeignMessage.Builder { C=3 }.Build(),
}.AddRepeatedString("qux").Build();
private const string MergeResultText =
"optional_int32: 1\n" +
"optional_int64: 2\n" +
"optional_string: \"foo\"\n" +
"optional_foreign_message {\n" +
" c: 3\n" +
"}\n" +
"repeated_string: \"qux\"\n" +
"repeated_string: \"bar\"\n";
[Test]
public void MergeFrom() {
TestAllTypes result = TestAllTypes.CreateBuilder(MergeDest).MergeFrom(MergeSource).Build();
Assert.AreEqual(MergeResultText, result.ToString());
}
/// <summary>
/// Test merging a DynamicMessage into a GeneratedMessage.
/// As long as they have the same descriptor, this should work, but it is an
/// entirely different code path.
/// </summary>
[Test]
public void MergeFromDynamic() {
TestAllTypes result = (TestAllTypes) TestAllTypes.CreateBuilder(MergeDest)
.MergeFrom(DynamicMessage.CreateBuilder(MergeSource).Build())
.Build();
Assert.AreEqual(MergeResultText, result.ToString());
}
/// <summary>
/// Test merging two DynamicMessages.
/// </summary>
[Test]
public void DynamicMergeFrom() {
DynamicMessage result = (DynamicMessage) DynamicMessage.CreateBuilder(MergeDest)
.MergeFrom((DynamicMessage) DynamicMessage.CreateBuilder(MergeSource).Build())
.Build();
Assert.AreEqual(MergeResultText, result.ToString());
}
// =================================================================
// Required-field-related tests.
private static readonly TestRequired TestRequiredUninitialized = TestRequired.DefaultInstance;
private static readonly TestRequired TestRequiredInitialized = new TestRequired.Builder {
A = 1, B = 2, C = 3
}.Build();
[Test]
public void Initialization() {
TestRequired.Builder builder = TestRequired.CreateBuilder();
Assert.IsFalse(builder.IsInitialized);
builder.A = 1;
Assert.IsFalse(builder.IsInitialized);
builder.B = 1;
Assert.IsFalse(builder.IsInitialized);
builder.C = 1;
Assert.IsTrue(builder.IsInitialized);
}
[Test]
public void RequiredForeign() {
TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder();
Assert.IsTrue(builder.IsInitialized);
builder.SetOptionalMessage(TestRequiredUninitialized);
Assert.IsFalse(builder.IsInitialized);
builder.SetOptionalMessage(TestRequiredInitialized);
Assert.IsTrue(builder.IsInitialized);
builder.AddRepeatedMessage(TestRequiredUninitialized);
Assert.IsFalse(builder.IsInitialized);
builder.SetRepeatedMessage(0, TestRequiredInitialized);
Assert.IsTrue(builder.IsInitialized);
}
[Test]
public void RequiredExtension() {
TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
Assert.IsTrue(builder.IsInitialized);
builder.SetExtension(TestRequired.Single, TestRequiredUninitialized);
Assert.IsFalse(builder.IsInitialized);
builder.SetExtension(TestRequired.Single, TestRequiredInitialized);
Assert.IsTrue(builder.IsInitialized);
builder.AddExtension(TestRequired.Multi, TestRequiredUninitialized);
Assert.IsFalse(builder.IsInitialized);
builder.SetExtension(TestRequired.Multi, 0, TestRequiredInitialized);
Assert.IsTrue(builder.IsInitialized);
}
[Test]
public void RequiredDynamic() {
MessageDescriptor descriptor = TestRequired.Descriptor;
DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor);
Assert.IsFalse(builder.IsInitialized);
builder[descriptor.FindDescriptor<FieldDescriptor>("a")] = 1;
Assert.IsFalse(builder.IsInitialized);
builder[descriptor.FindDescriptor<FieldDescriptor>("b")] = 1;
Assert.IsFalse(builder.IsInitialized);
builder[descriptor.FindDescriptor<FieldDescriptor>("c")] = 1;
Assert.IsTrue(builder.IsInitialized);
}
[Test]
public void RequiredDynamicForeign() {
MessageDescriptor descriptor = TestRequiredForeign.Descriptor;
DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor);
Assert.IsTrue(builder.IsInitialized);
builder[descriptor.FindDescriptor<FieldDescriptor>("optional_message")] = TestRequiredUninitialized;
Assert.IsFalse(builder.IsInitialized);
builder[descriptor.FindDescriptor<FieldDescriptor>("optional_message")] = TestRequiredInitialized;
Assert.IsTrue(builder.IsInitialized);
builder.AddRepeatedField(descriptor.FindDescriptor<FieldDescriptor>("repeated_message"), TestRequiredUninitialized);
Assert.IsFalse(builder.IsInitialized);
builder.SetRepeatedField(descriptor.FindDescriptor<FieldDescriptor>("repeated_message"), 0, TestRequiredInitialized);
Assert.IsTrue(builder.IsInitialized);
}
[Test]
public void UninitializedException() {
try {
TestRequired.CreateBuilder().Build();
Assert.Fail("Should have thrown an exception.");
} catch (UninitializedMessageException e) {
Assert.AreEqual("Message missing required fields: a, b, c", e.Message);
}
}
[Test]
public void BuildPartial() {
// We're mostly testing that no exception is thrown.
TestRequired message = TestRequired.CreateBuilder().BuildPartial();
Assert.IsFalse(message.IsInitialized);
}
[Test]
public void NestedUninitializedException() {
try {
TestRequiredForeign.CreateBuilder()
.SetOptionalMessage(TestRequiredUninitialized)
.AddRepeatedMessage(TestRequiredUninitialized)
.AddRepeatedMessage(TestRequiredUninitialized)
.Build();
Assert.Fail("Should have thrown an exception.");
} catch (UninitializedMessageException e) {
Assert.AreEqual(
"Message missing required fields: " +
"optional_message.a, " +
"optional_message.b, " +
"optional_message.c, " +
"repeated_message[0].a, " +
"repeated_message[0].b, " +
"repeated_message[0].c, " +
"repeated_message[1].a, " +
"repeated_message[1].b, " +
"repeated_message[1].c",
e.Message);
}
}
[Test]
public void BuildNestedPartial() {
// We're mostly testing that no exception is thrown.
TestRequiredForeign message =
TestRequiredForeign.CreateBuilder()
.SetOptionalMessage(TestRequiredUninitialized)
.AddRepeatedMessage(TestRequiredUninitialized)
.AddRepeatedMessage(TestRequiredUninitialized)
.BuildPartial();
Assert.IsFalse(message.IsInitialized);
}
[Test]
public void ParseUnititialized() {
try {
TestRequired.ParseFrom(ByteString.Empty);
Assert.Fail("Should have thrown an exception.");
} catch (InvalidProtocolBufferException e) {
Assert.AreEqual("Message missing required fields: a, b, c", e.Message);
}
}
[Test]
public void ParseNestedUnititialized() {
ByteString data =
TestRequiredForeign.CreateBuilder()
.SetOptionalMessage(TestRequiredUninitialized)
.AddRepeatedMessage(TestRequiredUninitialized)
.AddRepeatedMessage(TestRequiredUninitialized)
.BuildPartial().ToByteString();
try {
TestRequiredForeign.ParseFrom(data);
Assert.Fail("Should have thrown an exception.");
} catch (InvalidProtocolBufferException e) {
Assert.AreEqual(
"Message missing required fields: " +
"optional_message.a, " +
"optional_message.b, " +
"optional_message.c, " +
"repeated_message[0].a, " +
"repeated_message[0].b, " +
"repeated_message[0].c, " +
"repeated_message[1].a, " +
"repeated_message[1].b, " +
"repeated_message[1].c",
e.Message);
}
}
[Test]
public void DynamicUninitializedException() {
try {
DynamicMessage.CreateBuilder(TestRequired.Descriptor).Build();
Assert.Fail("Should have thrown an exception.");
} catch (UninitializedMessageException e) {
Assert.AreEqual("Message missing required fields: a, b, c", e.Message);
}
}
[Test]
public void DynamicBuildPartial() {
// We're mostly testing that no exception is thrown.
DynamicMessage message = DynamicMessage.CreateBuilder(TestRequired.Descriptor).BuildPartial();
Assert.IsFalse(message.Initialized);
}
[Test]
public void DynamicParseUnititialized() {
try {
MessageDescriptor descriptor = TestRequired.Descriptor;
DynamicMessage.ParseFrom(descriptor, ByteString.Empty);
Assert.Fail("Should have thrown an exception.");
} catch (InvalidProtocolBufferException e) {
Assert.AreEqual("Message missing required fields: a, b, c", e.Message);
}
}
}
}

36
csharp/ProtocolBuffers.Test/Properties/AssemblyInfo.cs
View file

@ -1,36 +0,0 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ProtocolBuffers.Test")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ProtocolBuffers.Test")]
[assembly: AssemblyCopyright("Copyright © 2008")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("54e627c3-daaa-4850-82cf-f25b7f097e78")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

BIN
csharp/ProtocolBuffers.Test/Properties/Google.ProtocolBuffers.Test.snk
View file

Binary file not shown.

92
csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
View file

@ -1,92 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{DD01ED24-3750-4567-9A23-1DB676A15610}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Google.ProtocolBuffers</RootNamespace>
<AssemblyName>Google.ProtocolBuffers.Test</AssemblyName>
<TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>Properties\Google.ProtocolBuffers.Test.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="nunit.framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77">
<SpecificVersion>False</SpecificVersion>
<HintPath>..\lib\nunit.framework.dll</HintPath>
</Reference>
<Reference Include="Rhino.Mocks, Version=3.5.0.2, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
<SpecificVersion>False</SpecificVersion>
<HintPath>..\lib\Rhino.Mocks.dll</HintPath>
</Reference>
<Reference Include="System" />
</ItemGroup>
<ItemGroup>
<Compile Include="AbstractMessageTest.cs" />
<Compile Include="ByteStringTest.cs" />
<Compile Include="CodedInputStreamTest.cs" />
<Compile Include="CodedOutputStreamTest.cs" />
<Compile Include="Collections\PopsicleListTest.cs" />
<Compile Include="DescriptorsTest.cs" />
<Compile Include="DynamicMessageTest.cs" />
<Compile Include="GeneratedMessageTest.cs" />
<Compile Include="MessageStreamIteratorTest.cs" />
<Compile Include="MessageStreamWriterTest.cs" />
<Compile Include="MessageTest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="ReflectionTester.cs" />
<Compile Include="ServiceTest.cs" />
<Compile Include="TestProtos\EnumWithNoOuter.cs" />
<Compile Include="TestProtos\MessageWithNoOuter.cs" />
<Compile Include="TestProtos\MultiFileProto.cs" />
<Compile Include="TestProtos\ServiceWithNoOuter.cs" />
<Compile Include="TestProtos\UnitTestEmbedOptimizeForProtoFile.cs" />
<Compile Include="TestProtos\UnitTestImportProtoFile.cs" />
<Compile Include="TestProtos\UnitTestMessageSetProtoFile.cs" />
<Compile Include="TestProtos\UnitTestOptimizeForProtoFile.cs" />
<Compile Include="TestProtos\UnitTestProtoFile.cs" />
<Compile Include="TestUtil.cs" />
<Compile Include="TextFormatTest.cs" />
<Compile Include="UnknownFieldSetTest.cs" />
<Compile Include="WireFormatTest.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj">
<Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project>
<Name>ProtocolBuffers</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<None Include="Properties\Google.ProtocolBuffers.Test.snk" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

796
csharp/ProtocolBuffers.Test/ReflectionTester.cs
View file

@ -1,796 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework;
namespace Google.ProtocolBuffers {
/// <summary>
/// Performs the same things that the methods of TestUtil do, but
/// via the reflection interface. This is its own class because it needs
/// to know what descriptor to use.
/// </summary>
internal class ReflectionTester {
private readonly MessageDescriptor baseDescriptor;
private readonly ExtensionRegistry extensionRegistry;
private readonly FileDescriptor file;
private readonly FileDescriptor importFile;
private readonly MessageDescriptor optionalGroup;
private readonly MessageDescriptor repeatedGroup;
private readonly MessageDescriptor nestedMessage;
private readonly MessageDescriptor foreignMessage;
private readonly MessageDescriptor importMessage;
private readonly FieldDescriptor groupA;
private readonly FieldDescriptor repeatedGroupA;
private readonly FieldDescriptor nestedB;
private readonly FieldDescriptor foreignC;
private readonly FieldDescriptor importD;
private readonly EnumDescriptor nestedEnum;
private readonly EnumDescriptor foreignEnum;
private readonly EnumDescriptor importEnum;
private readonly EnumValueDescriptor nestedFoo;
private readonly EnumValueDescriptor nestedBar;
private readonly EnumValueDescriptor nestedBaz;
private readonly EnumValueDescriptor foreignFoo;
private readonly EnumValueDescriptor foreignBar;
private readonly EnumValueDescriptor foreignBaz;
private readonly EnumValueDescriptor importFoo;
private readonly EnumValueDescriptor importBar;
private readonly EnumValueDescriptor importBaz;
/// <summary>
/// Constructs an instance that will expect messages using the given
/// descriptor. Normally <paramref name="baseDescriptor"/> should be
/// a descriptor for TestAllTypes. However, if extensionRegistry is non-null,
/// then baseDescriptor should be for TestAllExtensions instead, and instead of
/// reading and writing normal fields, the tester will read and write extensions.
/// All of the TestAllExtensions extensions must be registered in the registry.
/// </summary>
private ReflectionTester(MessageDescriptor baseDescriptor,
ExtensionRegistry extensionRegistry) {
this.baseDescriptor = baseDescriptor;
this.extensionRegistry = extensionRegistry;
this.file = baseDescriptor.File;
Assert.AreEqual(1, file.Dependencies.Count);
this.importFile = file.Dependencies[0];
MessageDescriptor testAllTypes;
if (extensionRegistry == null) {
testAllTypes = baseDescriptor;
} else {
testAllTypes = file.FindTypeByName<MessageDescriptor>("TestAllTypes");
Assert.IsNotNull(testAllTypes);
}
if (extensionRegistry == null) {
this.optionalGroup =
baseDescriptor.FindDescriptor<MessageDescriptor>("OptionalGroup");
this.repeatedGroup =
baseDescriptor.FindDescriptor<MessageDescriptor>("RepeatedGroup");
} else {
this.optionalGroup =
file.FindTypeByName<MessageDescriptor>("OptionalGroup_extension");
this.repeatedGroup =
file.FindTypeByName<MessageDescriptor>("RepeatedGroup_extension");
}
this.nestedMessage = testAllTypes.FindDescriptor<MessageDescriptor>("NestedMessage");
this.foreignMessage = file.FindTypeByName<MessageDescriptor>("ForeignMessage");
this.importMessage = importFile.FindTypeByName<MessageDescriptor>("ImportMessage");
this.nestedEnum = testAllTypes.FindDescriptor<EnumDescriptor>("NestedEnum");
this.foreignEnum = file.FindTypeByName<EnumDescriptor>("ForeignEnum");
this.importEnum = importFile.FindTypeByName<EnumDescriptor>("ImportEnum");
Assert.IsNotNull(optionalGroup );
Assert.IsNotNull(repeatedGroup );
Assert.IsNotNull(nestedMessage );
Assert.IsNotNull(foreignMessage);
Assert.IsNotNull(importMessage );
Assert.IsNotNull(nestedEnum );
Assert.IsNotNull(foreignEnum );
Assert.IsNotNull(importEnum );
this.nestedB = nestedMessage.FindDescriptor<FieldDescriptor>("bb");
this.foreignC = foreignMessage.FindDescriptor<FieldDescriptor>("c");
this.importD = importMessage .FindDescriptor<FieldDescriptor>("d");
this.nestedFoo = nestedEnum.FindValueByName("FOO");
this.nestedBar = nestedEnum.FindValueByName("BAR");
this.nestedBaz = nestedEnum.FindValueByName("BAZ");
this.foreignFoo = foreignEnum.FindValueByName("FOREIGN_FOO");
this.foreignBar = foreignEnum.FindValueByName("FOREIGN_BAR");
this.foreignBaz = foreignEnum.FindValueByName("FOREIGN_BAZ");
this.importFoo = importEnum.FindValueByName("IMPORT_FOO");
this.importBar = importEnum.FindValueByName("IMPORT_BAR");
this.importBaz = importEnum.FindValueByName("IMPORT_BAZ");
this.groupA = optionalGroup.FindDescriptor<FieldDescriptor>("a");
this.repeatedGroupA = repeatedGroup.FindDescriptor<FieldDescriptor>("a");
Assert.IsNotNull(groupA );
Assert.IsNotNull(repeatedGroupA);
Assert.IsNotNull(nestedB );
Assert.IsNotNull(foreignC );
Assert.IsNotNull(importD );
Assert.IsNotNull(nestedFoo );
Assert.IsNotNull(nestedBar );
Assert.IsNotNull(nestedBaz );
Assert.IsNotNull(foreignFoo );
Assert.IsNotNull(foreignBar );
Assert.IsNotNull(foreignBaz );
Assert.IsNotNull(importFoo );
Assert.IsNotNull(importBar );
Assert.IsNotNull(importBaz );
}
/// <summary>
/// Creates an instance for the TestAllTypes message, with no extension registry.
/// </summary>
public static ReflectionTester CreateTestAllTypesInstance() {
return new ReflectionTester(TestAllTypes.Descriptor, null);
}
/// <summary>
/// Creates an instance for the TestAllExtensions message, with an
/// extension registry from TestUtil.CreateExtensionRegistry.
/// </summary>
public static ReflectionTester CreateTestAllExtensionsInstance() {
return new ReflectionTester(TestAllExtensions.Descriptor, TestUtil.CreateExtensionRegistry());
}
/// <summary>
/// Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes.
/// </summary>
private FieldDescriptor f(String name) {
FieldDescriptor result;
if (extensionRegistry == null) {
result = baseDescriptor.FindDescriptor<FieldDescriptor>(name);
} else {
result = file.FindTypeByName<FieldDescriptor>(name + "_extension");
}
Assert.IsNotNull(result);
return result;
}
/// <summary>
/// Calls parent.CreateBuilderForField() or uses the extension registry
/// to find an appropriate builder, depending on what type is being tested.
/// </summary>
private IBuilder CreateBuilderForField(IBuilder parent, FieldDescriptor field) {
if (extensionRegistry == null) {
return parent.CreateBuilderForField(field);
} else {
ExtensionInfo extension = extensionRegistry[field.ContainingType, field.FieldNumber];
Assert.IsNotNull(extension);
Assert.IsNotNull(extension.DefaultInstance);
return extension.DefaultInstance.WeakCreateBuilderForType();
}
}
/// <summary>
/// Sets every field of the message to the values expected by
/// AssertAllFieldsSet, using the reflection interface.
/// </summary>
/// <param name="message"></param>
internal void SetAllFieldsViaReflection(IBuilder message) {
message[f("optional_int32" )] = 101 ;
message[f("optional_int64" )] = 102L;
message[f("optional_uint32" )] = 103U ;
message[f("optional_uint64" )] = 104UL;
message[f("optional_sint32" )] = 105 ;
message[f("optional_sint64" )] = 106L;
message[f("optional_fixed32" )] = 107U ;
message[f("optional_fixed64" )] = 108UL;
message[f("optional_sfixed32")] = 109 ;
message[f("optional_sfixed64")] = 110L;
message[f("optional_float" )] = 111F;
message[f("optional_double" )] = 112D;
message[f("optional_bool" )] = true;
message[f("optional_string" )] = "115";
message[f("optional_bytes")] = TestUtil.ToBytes("116");
message[f("optionalgroup")] = CreateBuilderForField(message, f("optionalgroup")).SetField(groupA, 117).WeakBuild();
message[f("optional_nested_message")] = CreateBuilderForField(message, f("optional_nested_message")).SetField(nestedB, 118).WeakBuild();
message[f("optional_foreign_message")] = CreateBuilderForField(message, f("optional_foreign_message")).SetField(foreignC, 119).WeakBuild();
message[f("optional_import_message")] = CreateBuilderForField(message, f("optional_import_message")).SetField(importD, 120).WeakBuild();
message[f("optional_nested_enum" )] = nestedBaz;
message[f("optional_foreign_enum")] = foreignBaz;
message[f("optional_import_enum" )] = importBaz;
message[f("optional_string_piece" )] = "124";
message[f("optional_cord" )] = "125";
// -----------------------------------------------------------------
message.WeakAddRepeatedField(f("repeated_int32" ), 201 );
message.WeakAddRepeatedField(f("repeated_int64" ), 202L);
message.WeakAddRepeatedField(f("repeated_uint32" ), 203U );
message.WeakAddRepeatedField(f("repeated_uint64" ), 204UL);
message.WeakAddRepeatedField(f("repeated_sint32" ), 205 );
message.WeakAddRepeatedField(f("repeated_sint64" ), 206L);
message.WeakAddRepeatedField(f("repeated_fixed32" ), 207U );
message.WeakAddRepeatedField(f("repeated_fixed64" ), 208UL);
message.WeakAddRepeatedField(f("repeated_sfixed32"), 209 );
message.WeakAddRepeatedField(f("repeated_sfixed64"), 210L);
message.WeakAddRepeatedField(f("repeated_float" ), 211F);
message.WeakAddRepeatedField(f("repeated_double" ), 212D);
message.WeakAddRepeatedField(f("repeated_bool" ), true);
message.WeakAddRepeatedField(f("repeated_string" ), "215");
message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("216"));
message.WeakAddRepeatedField(f("repeatedgroup"), CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 217).WeakBuild());
message.WeakAddRepeatedField(f("repeated_nested_message"), CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 218).WeakBuild());
message.WeakAddRepeatedField(f("repeated_foreign_message"), CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 219).WeakBuild());
message.WeakAddRepeatedField(f("repeated_import_message"), CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 220).WeakBuild());
message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBar);
message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBar);
message.WeakAddRepeatedField(f("repeated_import_enum" ), importBar);
message.WeakAddRepeatedField(f("repeated_string_piece" ), "224");
message.WeakAddRepeatedField(f("repeated_cord" ), "225");
// Add a second one of each field.
message.WeakAddRepeatedField(f("repeated_int32" ), 301 );
message.WeakAddRepeatedField(f("repeated_int64" ), 302L);
message.WeakAddRepeatedField(f("repeated_uint32" ), 303U );
message.WeakAddRepeatedField(f("repeated_uint64" ), 304UL);
message.WeakAddRepeatedField(f("repeated_sint32" ), 305 );
message.WeakAddRepeatedField(f("repeated_sint64" ), 306L);
message.WeakAddRepeatedField(f("repeated_fixed32" ), 307U );
message.WeakAddRepeatedField(f("repeated_fixed64" ), 308UL);
message.WeakAddRepeatedField(f("repeated_sfixed32"), 309 );
message.WeakAddRepeatedField(f("repeated_sfixed64"), 310L);
message.WeakAddRepeatedField(f("repeated_float" ), 311F);
message.WeakAddRepeatedField(f("repeated_double" ), 312D);
message.WeakAddRepeatedField(f("repeated_bool" ), false);
message.WeakAddRepeatedField(f("repeated_string" ), "315");
message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("316"));
message.WeakAddRepeatedField(f("repeatedgroup"),
CreateBuilderForField(message, f("repeatedgroup"))
.SetField(repeatedGroupA, 317).WeakBuild());
message.WeakAddRepeatedField(f("repeated_nested_message"),
CreateBuilderForField(message, f("repeated_nested_message"))
.SetField(nestedB, 318).WeakBuild());
message.WeakAddRepeatedField(f("repeated_foreign_message"),
CreateBuilderForField(message, f("repeated_foreign_message"))
.SetField(foreignC, 319).WeakBuild());
message.WeakAddRepeatedField(f("repeated_import_message"),
CreateBuilderForField(message, f("repeated_import_message"))
.SetField(importD, 320).WeakBuild());
message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBaz);
message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBaz);
message.WeakAddRepeatedField(f("repeated_import_enum" ), importBaz);
message.WeakAddRepeatedField(f("repeated_string_piece" ), "324");
message.WeakAddRepeatedField(f("repeated_cord" ), "325");
// -----------------------------------------------------------------
message[f("default_int32" )] = 401 ;
message[f("default_int64" )] = 402L;
message[f("default_uint32" )] = 403U ;
message[f("default_uint64" )] = 404UL;
message[f("default_sint32" )] = 405 ;
message[f("default_sint64" )] = 406L;
message[f("default_fixed32" )] = 407U ;
message[f("default_fixed64" )] = 408UL;
message[f("default_sfixed32")] = 409 ;
message[f("default_sfixed64")] = 410L;
message[f("default_float" )] = 411F;
message[f("default_double" )] = 412D;
message[f("default_bool" )] = false;
message[f("default_string" )] = "415";
message[f("default_bytes" )] = TestUtil.ToBytes("416");
message[f("default_nested_enum" )] = nestedFoo;
message[f("default_foreign_enum")] = foreignFoo;
message[f("default_import_enum" )] = importFoo;
message[f("default_string_piece" )] = "424";
message[f("default_cord" )] = "425";
}
// -------------------------------------------------------------------
/// <summary>
/// Modify the repeated fields of the specified message to contain the
/// values expected by AssertRepeatedFieldsModified, using the IBuilder
/// reflection interface.
/// </summary>
internal void ModifyRepeatedFieldsViaReflection(IBuilder message) {
message[f("repeated_int32" ), 1] = 501 ;
message[f("repeated_int64" ), 1] = 502L;
message[f("repeated_uint32" ), 1] = 503U ;
message[f("repeated_uint64" ), 1] = 504UL;
message[f("repeated_sint32" ), 1] = 505 ;
message[f("repeated_sint64" ), 1] = 506L;
message[f("repeated_fixed32" ), 1] = 507U ;
message[f("repeated_fixed64" ), 1] = 508UL;
message[f("repeated_sfixed32"), 1] = 509 ;
message[f("repeated_sfixed64"), 1] = 510L;
message[f("repeated_float" ), 1] = 511F;
message[f("repeated_double" ), 1] = 512D;
message[f("repeated_bool" ), 1] = true;
message[f("repeated_string" ), 1] = "515";
message.SetRepeatedField(f("repeated_bytes" ), 1, TestUtil.ToBytes("516"));
message.SetRepeatedField(f("repeatedgroup"), 1, CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 517).WeakBuild());
message.SetRepeatedField(f("repeated_nested_message"), 1, CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 518).WeakBuild());
message.SetRepeatedField(f("repeated_foreign_message"), 1, CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 519).WeakBuild());
message.SetRepeatedField(f("repeated_import_message"), 1, CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 520).WeakBuild());
message[f("repeated_nested_enum" ), 1] = nestedFoo;
message[f("repeated_foreign_enum"), 1] = foreignFoo;
message[f("repeated_import_enum" ), 1] = importFoo;
message[f("repeated_string_piece"), 1] = "524";
message[f("repeated_cord"), 1] = "525";
}
// -------------------------------------------------------------------
/// <summary>
/// Asserts that all fields of the specified message are set to the values
/// assigned by SetAllFields, using the IMessage reflection interface.
/// </summary>
public void AssertAllFieldsSetViaReflection(IMessage message) {
Assert.IsTrue(message.HasField(f("optional_int32" )));
Assert.IsTrue(message.HasField(f("optional_int64" )));
Assert.IsTrue(message.HasField(f("optional_uint32" )));
Assert.IsTrue(message.HasField(f("optional_uint64" )));
Assert.IsTrue(message.HasField(f("optional_sint32" )));
Assert.IsTrue(message.HasField(f("optional_sint64" )));
Assert.IsTrue(message.HasField(f("optional_fixed32" )));
Assert.IsTrue(message.HasField(f("optional_fixed64" )));
Assert.IsTrue(message.HasField(f("optional_sfixed32")));
Assert.IsTrue(message.HasField(f("optional_sfixed64")));
Assert.IsTrue(message.HasField(f("optional_float" )));
Assert.IsTrue(message.HasField(f("optional_double" )));
Assert.IsTrue(message.HasField(f("optional_bool" )));
Assert.IsTrue(message.HasField(f("optional_string" )));
Assert.IsTrue(message.HasField(f("optional_bytes" )));
Assert.IsTrue(message.HasField(f("optionalgroup" )));
Assert.IsTrue(message.HasField(f("optional_nested_message" )));
Assert.IsTrue(message.HasField(f("optional_foreign_message")));
Assert.IsTrue(message.HasField(f("optional_import_message" )));
Assert.IsTrue(((IMessage)message[f("optionalgroup")]).HasField(groupA));
Assert.IsTrue(((IMessage)message[f("optional_nested_message")]).HasField(nestedB));
Assert.IsTrue(((IMessage)message[f("optional_foreign_message")]).HasField(foreignC));
Assert.IsTrue(((IMessage)message[f("optional_import_message")]).HasField(importD));
Assert.IsTrue(message.HasField(f("optional_nested_enum" )));
Assert.IsTrue(message.HasField(f("optional_foreign_enum")));
Assert.IsTrue(message.HasField(f("optional_import_enum" )));
Assert.IsTrue(message.HasField(f("optional_string_piece")));
Assert.IsTrue(message.HasField(f("optional_cord")));
Assert.AreEqual(101 , message[f("optional_int32" )]);
Assert.AreEqual(102L , message[f("optional_int64" )]);
Assert.AreEqual(103U , message[f("optional_uint32" )]);
Assert.AreEqual(104UL , message[f("optional_uint64" )]);
Assert.AreEqual(105 , message[f("optional_sint32" )]);
Assert.AreEqual(106L , message[f("optional_sint64" )]);
Assert.AreEqual(107U , message[f("optional_fixed32" )]);
Assert.AreEqual(108UL , message[f("optional_fixed64" )]);
Assert.AreEqual(109 , message[f("optional_sfixed32")]);
Assert.AreEqual(110L , message[f("optional_sfixed64")]);
Assert.AreEqual(111F , message[f("optional_float" )]);
Assert.AreEqual(112D , message[f("optional_double" )]);
Assert.AreEqual(true , message[f("optional_bool" )]);
Assert.AreEqual("115", message[f("optional_string" )]);
Assert.AreEqual(TestUtil.ToBytes("116"), message[f("optional_bytes")]);
Assert.AreEqual(117,((IMessage)message[f("optionalgroup")])[groupA]);
Assert.AreEqual(118,((IMessage)message[f("optional_nested_message")])[nestedB]);
Assert.AreEqual(119,((IMessage)message[f("optional_foreign_message")])[foreignC]);
Assert.AreEqual(120,((IMessage)message[f("optional_import_message")])[importD]);
Assert.AreEqual( nestedBaz, message[f("optional_nested_enum" )]);
Assert.AreEqual(foreignBaz, message[f("optional_foreign_enum")]);
Assert.AreEqual( importBaz, message[f("optional_import_enum" )]);
Assert.AreEqual("124", message[f("optional_string_piece")]);
Assert.AreEqual("125", message[f("optional_cord")]);
// -----------------------------------------------------------------
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord")));
Assert.AreEqual(201 , message[f("repeated_int32" ), 0]);
Assert.AreEqual(202L , message[f("repeated_int64" ), 0]);
Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]);
Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]);
Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]);
Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]);
Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]);
Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]);
Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]);
Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]);
Assert.AreEqual(211F , message[f("repeated_float" ), 0]);
Assert.AreEqual(212D , message[f("repeated_double" ), 0]);
Assert.AreEqual(true , message[f("repeated_bool" ), 0]);
Assert.AreEqual("215", message[f("repeated_string" ), 0]);
Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]);
Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]);
Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]);
Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]);
Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]);
Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]);
Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]);
Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]);
Assert.AreEqual("224", message[f("repeated_string_piece"), 0]);
Assert.AreEqual("225", message[f("repeated_cord"), 0]);
Assert.AreEqual(301 , message[f("repeated_int32" ), 1]);
Assert.AreEqual(302L , message[f("repeated_int64" ), 1]);
Assert.AreEqual(303U , message[f("repeated_uint32" ), 1]);
Assert.AreEqual(304UL, message[f("repeated_uint64" ), 1]);
Assert.AreEqual(305 , message[f("repeated_sint32" ), 1]);
Assert.AreEqual(306L , message[f("repeated_sint64" ), 1]);
Assert.AreEqual(307U , message[f("repeated_fixed32" ), 1]);
Assert.AreEqual(308UL, message[f("repeated_fixed64" ), 1]);
Assert.AreEqual(309 , message[f("repeated_sfixed32"), 1]);
Assert.AreEqual(310L , message[f("repeated_sfixed64"), 1]);
Assert.AreEqual(311F , message[f("repeated_float" ), 1]);
Assert.AreEqual(312D , message[f("repeated_double" ), 1]);
Assert.AreEqual(false, message[f("repeated_bool" ), 1]);
Assert.AreEqual("315", message[f("repeated_string" ), 1]);
Assert.AreEqual(TestUtil.ToBytes("316"), message[f("repeated_bytes"), 1]);
Assert.AreEqual(317,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]);
Assert.AreEqual(318,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]);
Assert.AreEqual(319,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]);
Assert.AreEqual(320,((IMessage)message[f("repeated_import_message"), 1])[importD]);
Assert.AreEqual( nestedBaz, message[f("repeated_nested_enum" ),1]);
Assert.AreEqual(foreignBaz, message[f("repeated_foreign_enum"),1]);
Assert.AreEqual( importBaz, message[f("repeated_import_enum" ),1]);
Assert.AreEqual("324", message[f("repeated_string_piece"), 1]);
Assert.AreEqual("325", message[f("repeated_cord"), 1]);
// -----------------------------------------------------------------
Assert.IsTrue(message.HasField(f("default_int32" )));
Assert.IsTrue(message.HasField(f("default_int64" )));
Assert.IsTrue(message.HasField(f("default_uint32" )));
Assert.IsTrue(message.HasField(f("default_uint64" )));
Assert.IsTrue(message.HasField(f("default_sint32" )));
Assert.IsTrue(message.HasField(f("default_sint64" )));
Assert.IsTrue(message.HasField(f("default_fixed32" )));
Assert.IsTrue(message.HasField(f("default_fixed64" )));
Assert.IsTrue(message.HasField(f("default_sfixed32")));
Assert.IsTrue(message.HasField(f("default_sfixed64")));
Assert.IsTrue(message.HasField(f("default_float" )));
Assert.IsTrue(message.HasField(f("default_double" )));
Assert.IsTrue(message.HasField(f("default_bool" )));
Assert.IsTrue(message.HasField(f("default_string" )));
Assert.IsTrue(message.HasField(f("default_bytes" )));
Assert.IsTrue(message.HasField(f("default_nested_enum" )));
Assert.IsTrue(message.HasField(f("default_foreign_enum")));
Assert.IsTrue(message.HasField(f("default_import_enum" )));
Assert.IsTrue(message.HasField(f("default_string_piece")));
Assert.IsTrue(message.HasField(f("default_cord")));
Assert.AreEqual(401 , message[f("default_int32" )]);
Assert.AreEqual(402L , message[f("default_int64" )]);
Assert.AreEqual(403U , message[f("default_uint32" )]);
Assert.AreEqual(404UL, message[f("default_uint64" )]);
Assert.AreEqual(405 , message[f("default_sint32" )]);
Assert.AreEqual(406L , message[f("default_sint64" )]);
Assert.AreEqual(407U , message[f("default_fixed32" )]);
Assert.AreEqual(408UL, message[f("default_fixed64" )]);
Assert.AreEqual(409 , message[f("default_sfixed32")]);
Assert.AreEqual(410L , message[f("default_sfixed64")]);
Assert.AreEqual(411F , message[f("default_float" )]);
Assert.AreEqual(412D , message[f("default_double" )]);
Assert.AreEqual(false, message[f("default_bool" )]);
Assert.AreEqual("415", message[f("default_string" )]);
Assert.AreEqual(TestUtil.ToBytes("416"), message[f("default_bytes")]);
Assert.AreEqual( nestedFoo, message[f("default_nested_enum" )]);
Assert.AreEqual(foreignFoo, message[f("default_foreign_enum")]);
Assert.AreEqual( importFoo, message[f("default_import_enum" )]);
Assert.AreEqual("424", message[f("default_string_piece")]);
Assert.AreEqual("425", message[f("default_cord")]);
}
/// <summary>
/// Assert that all fields of the message are cleared, and that
/// getting the fields returns their default values, using the reflection interface.
/// </summary>
public void AssertClearViaReflection(IMessage message) {
// has_blah() should initially be false for all optional fields.
Assert.IsFalse(message.HasField(f("optional_int32" )));
Assert.IsFalse(message.HasField(f("optional_int64" )));
Assert.IsFalse(message.HasField(f("optional_uint32" )));
Assert.IsFalse(message.HasField(f("optional_uint64" )));
Assert.IsFalse(message.HasField(f("optional_sint32" )));
Assert.IsFalse(message.HasField(f("optional_sint64" )));
Assert.IsFalse(message.HasField(f("optional_fixed32" )));
Assert.IsFalse(message.HasField(f("optional_fixed64" )));
Assert.IsFalse(message.HasField(f("optional_sfixed32")));
Assert.IsFalse(message.HasField(f("optional_sfixed64")));
Assert.IsFalse(message.HasField(f("optional_float" )));
Assert.IsFalse(message.HasField(f("optional_double" )));
Assert.IsFalse(message.HasField(f("optional_bool" )));
Assert.IsFalse(message.HasField(f("optional_string" )));
Assert.IsFalse(message.HasField(f("optional_bytes" )));
Assert.IsFalse(message.HasField(f("optionalgroup" )));
Assert.IsFalse(message.HasField(f("optional_nested_message" )));
Assert.IsFalse(message.HasField(f("optional_foreign_message")));
Assert.IsFalse(message.HasField(f("optional_import_message" )));
Assert.IsFalse(message.HasField(f("optional_nested_enum" )));
Assert.IsFalse(message.HasField(f("optional_foreign_enum")));
Assert.IsFalse(message.HasField(f("optional_import_enum" )));
Assert.IsFalse(message.HasField(f("optional_string_piece")));
Assert.IsFalse(message.HasField(f("optional_cord")));
// Optional fields without defaults are set to zero or something like it.
Assert.AreEqual(0 , message[f("optional_int32" )]);
Assert.AreEqual(0L , message[f("optional_int64" )]);
Assert.AreEqual(0U , message[f("optional_uint32" )]);
Assert.AreEqual(0UL , message[f("optional_uint64" )]);
Assert.AreEqual(0 , message[f("optional_sint32" )]);
Assert.AreEqual(0L , message[f("optional_sint64" )]);
Assert.AreEqual(0U , message[f("optional_fixed32" )]);
Assert.AreEqual(0UL , message[f("optional_fixed64" )]);
Assert.AreEqual(0 , message[f("optional_sfixed32")]);
Assert.AreEqual(0L , message[f("optional_sfixed64")]);
Assert.AreEqual(0F , message[f("optional_float" )]);
Assert.AreEqual(0D , message[f("optional_double" )]);
Assert.AreEqual(false, message[f("optional_bool" )]);
Assert.AreEqual("" , message[f("optional_string" )]);
Assert.AreEqual(ByteString.Empty, message[f("optional_bytes")]);
// Embedded messages should also be clear.
Assert.IsFalse(((IMessage)message[f("optionalgroup")]).HasField(groupA));
Assert.IsFalse(((IMessage)message[f("optional_nested_message")])
.HasField(nestedB));
Assert.IsFalse(((IMessage)message[f("optional_foreign_message")])
.HasField(foreignC));
Assert.IsFalse(((IMessage)message[f("optional_import_message")])
.HasField(importD));
Assert.AreEqual(0,((IMessage)message[f("optionalgroup")])[groupA]);
Assert.AreEqual(0,((IMessage)message[f("optional_nested_message")])[nestedB]);
Assert.AreEqual(0,((IMessage)message[f("optional_foreign_message")])[foreignC]);
Assert.AreEqual(0,((IMessage)message[f("optional_import_message")])[importD]);
// Enums without defaults are set to the first value in the enum.
Assert.AreEqual( nestedFoo, message[f("optional_nested_enum" )]);
Assert.AreEqual(foreignFoo, message[f("optional_foreign_enum")]);
Assert.AreEqual( importFoo, message[f("optional_import_enum" )]);
Assert.AreEqual("", message[f("optional_string_piece")]);
Assert.AreEqual("", message[f("optional_cord")]);
// Repeated fields are empty.
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int32" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int64" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint32" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint64" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint32" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint64" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed32" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed64" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_float" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_double" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bool" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bytes" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeatedgroup" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_message" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_message" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_enum" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_enum" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_enum" )));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string_piece")));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_cord")));
// has_blah() should also be false for all default fields.
Assert.IsFalse(message.HasField(f("default_int32" )));
Assert.IsFalse(message.HasField(f("default_int64" )));
Assert.IsFalse(message.HasField(f("default_uint32" )));
Assert.IsFalse(message.HasField(f("default_uint64" )));
Assert.IsFalse(message.HasField(f("default_sint32" )));
Assert.IsFalse(message.HasField(f("default_sint64" )));
Assert.IsFalse(message.HasField(f("default_fixed32" )));
Assert.IsFalse(message.HasField(f("default_fixed64" )));
Assert.IsFalse(message.HasField(f("default_sfixed32")));
Assert.IsFalse(message.HasField(f("default_sfixed64")));
Assert.IsFalse(message.HasField(f("default_float" )));
Assert.IsFalse(message.HasField(f("default_double" )));
Assert.IsFalse(message.HasField(f("default_bool" )));
Assert.IsFalse(message.HasField(f("default_string" )));
Assert.IsFalse(message.HasField(f("default_bytes" )));
Assert.IsFalse(message.HasField(f("default_nested_enum" )));
Assert.IsFalse(message.HasField(f("default_foreign_enum")));
Assert.IsFalse(message.HasField(f("default_import_enum" )));
Assert.IsFalse(message.HasField(f("default_string_piece" )));
Assert.IsFalse(message.HasField(f("default_cord" )));
// Fields with defaults have their default values (duh).
Assert.AreEqual( 41 , message[f("default_int32" )]);
Assert.AreEqual( 42L , message[f("default_int64" )]);
Assert.AreEqual( 43U , message[f("default_uint32" )]);
Assert.AreEqual( 44UL , message[f("default_uint64" )]);
Assert.AreEqual(-45 , message[f("default_sint32" )]);
Assert.AreEqual( 46L , message[f("default_sint64" )]);
Assert.AreEqual( 47U , message[f("default_fixed32" )]);
Assert.AreEqual( 48UL , message[f("default_fixed64" )]);
Assert.AreEqual( 49 , message[f("default_sfixed32")]);
Assert.AreEqual(-50L , message[f("default_sfixed64")]);
Assert.AreEqual( 51.5F , message[f("default_float" )]);
Assert.AreEqual( 52e3D , message[f("default_double" )]);
Assert.AreEqual(true , message[f("default_bool" )]);
Assert.AreEqual("hello", message[f("default_string" )]);
Assert.AreEqual(TestUtil.ToBytes("world"), message[f("default_bytes")]);
Assert.AreEqual( nestedBar, message[f("default_nested_enum" )]);
Assert.AreEqual(foreignBar, message[f("default_foreign_enum")]);
Assert.AreEqual( importBar, message[f("default_import_enum" )]);
Assert.AreEqual("abc", message[f("default_string_piece")]);
Assert.AreEqual("123", message[f("default_cord")]);
}
// ---------------------------------------------------------------
internal void AssertRepeatedFieldsModifiedViaReflection(IMessage message) {
// ModifyRepeatedFields only sets the second repeated element of each
// field. In addition to verifying this, we also verify that the first
// element and size were *not* modified.
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" )));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord")));
Assert.AreEqual(201 , message[f("repeated_int32" ), 0]);
Assert.AreEqual(202L , message[f("repeated_int64" ), 0]);
Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]);
Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]);
Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]);
Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]);
Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]);
Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]);
Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]);
Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]);
Assert.AreEqual(211F , message[f("repeated_float" ), 0]);
Assert.AreEqual(212D , message[f("repeated_double" ), 0]);
Assert.AreEqual(true , message[f("repeated_bool" ), 0]);
Assert.AreEqual("215", message[f("repeated_string" ), 0]);
Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]);
Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]);
Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]);
Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]);
Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]);
Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]);
Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]);
Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]);
Assert.AreEqual("224", message[f("repeated_string_piece"), 0]);
Assert.AreEqual("225", message[f("repeated_cord"), 0]);
Assert.AreEqual(501 , message[f("repeated_int32" ), 1]);
Assert.AreEqual(502L , message[f("repeated_int64" ), 1]);
Assert.AreEqual(503U , message[f("repeated_uint32" ), 1]);
Assert.AreEqual(504UL, message[f("repeated_uint64" ), 1]);
Assert.AreEqual(505 , message[f("repeated_sint32" ), 1]);
Assert.AreEqual(506L , message[f("repeated_sint64" ), 1]);
Assert.AreEqual(507U , message[f("repeated_fixed32" ), 1]);
Assert.AreEqual(508UL, message[f("repeated_fixed64" ), 1]);
Assert.AreEqual(509 , message[f("repeated_sfixed32"), 1]);
Assert.AreEqual(510L , message[f("repeated_sfixed64"), 1]);
Assert.AreEqual(511F , message[f("repeated_float" ), 1]);
Assert.AreEqual(512D , message[f("repeated_double" ), 1]);
Assert.AreEqual(true , message[f("repeated_bool" ), 1]);
Assert.AreEqual("515", message[f("repeated_string" ), 1]);
Assert.AreEqual(TestUtil.ToBytes("516"), message[f("repeated_bytes"), 1]);
Assert.AreEqual(517,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]);
Assert.AreEqual(518,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]);
Assert.AreEqual(519,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]);
Assert.AreEqual(520,((IMessage)message[f("repeated_import_message"), 1])[importD]);
Assert.AreEqual( nestedFoo, message[f("repeated_nested_enum" ),1]);
Assert.AreEqual(foreignFoo, message[f("repeated_foreign_enum"),1]);
Assert.AreEqual( importFoo, message[f("repeated_import_enum" ),1]);
Assert.AreEqual("524", message[f("repeated_string_piece"), 1]);
Assert.AreEqual("525", message[f("repeated_cord"), 1]);
}
}
}

178
csharp/ProtocolBuffers.Test/ServiceTest.cs
View file

@ -1,178 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework;
using Rhino.Mocks;
using Rhino.Mocks.Constraints;
namespace Google.ProtocolBuffers {
/// <summary>
/// Tests for generated service classes.
/// TODO(jonskeet): Convert the mocking tests using Rhino.Mocks.
/// </summary>
[TestFixture]
public class ServiceTest {
delegate void Action<T1, T2>(T1 t1, T2 t2);
private static readonly MethodDescriptor FooDescriptor = TestService.Descriptor.Methods[0];
private static readonly MethodDescriptor BarDescriptor = TestService.Descriptor.Methods[1];
[Test]
public void GetRequestPrototype() {
TestService service = new TestServiceImpl();
Assert.AreSame(service.GetRequestPrototype(FooDescriptor), FooRequest.DefaultInstance);
Assert.AreSame(service.GetRequestPrototype(BarDescriptor), BarRequest.DefaultInstance);
}
[Test]
public void GetResponsePrototype() {
TestService service = new TestServiceImpl();
Assert.AreSame(service.GetResponsePrototype(FooDescriptor), FooResponse.DefaultInstance);
Assert.AreSame(service.GetResponsePrototype(BarDescriptor), BarResponse.DefaultInstance);
}
[Test]
public void CallMethodFoo() {
MockRepository mocks = new MockRepository();
FooRequest fooRequest = FooRequest.CreateBuilder().Build();
FooResponse fooResponse = FooResponse.CreateBuilder().Build();
IRpcController controller = mocks.StrictMock<IRpcController>();
bool fooCalled = false;
TestService service = new TestServiceImpl((request, responseAction) => {
Assert.AreSame(fooRequest, request);
fooCalled = true;
responseAction(fooResponse);
}, null, controller);
bool doneHandlerCalled = false;
Action<IMessage> doneHandler = (response => {
Assert.AreSame(fooResponse, response);
doneHandlerCalled = true;
});
using (mocks.Record()) {
// No mock interactions to record
}
service.CallMethod(FooDescriptor, controller, fooRequest, doneHandler);
Assert.IsTrue(doneHandlerCalled);
Assert.IsTrue(fooCalled);
mocks.VerifyAll();
}
delegate void CallFooDelegate(MethodDescriptor descriptor, IRpcController controller,
IMessage request, IMessage response, Action<IMessage> doneHandler);
/// <summary>
/// Tests the generated stub handling of Foo. By this stage we're reasonably confident
/// that the choice between Foo and Bar is arbitrary, hence the lack of a corresponding Bar
/// test.
/// </summary>
[Test]
public void GeneratedStubFooCall() {
FooRequest fooRequest = FooRequest.CreateBuilder().Build();
MockRepository mocks = new MockRepository();
IRpcChannel mockChannel = mocks.StrictMock<IRpcChannel>();
IRpcController mockController = mocks.StrictMock<IRpcController>();
TestService service = TestService.CreateStub(mockChannel);
Action<FooResponse> doneHandler = mocks.StrictMock<Action<FooResponse>>();
using (mocks.Record()) {
// Nasty way of mocking out "the channel calls the done handler".
Expect.Call(() => mockChannel.CallMethod(null, null, null, null, null))
.IgnoreArguments()
.Constraints(Is.Same(FooDescriptor), Is.Same(mockController), Is.Same(fooRequest),
Is.Same(FooResponse.DefaultInstance), Is.Anything())
.Do((CallFooDelegate) ((p1, p2, p3, response, done) => done(response)));
doneHandler.Invoke(FooResponse.DefaultInstance);
}
service.Foo(mockController, fooRequest, doneHandler);
mocks.VerifyAll();
}
[Test]
public void CallMethodBar() {
MockRepository mocks = new MockRepository();
BarRequest barRequest = BarRequest.CreateBuilder().Build();
BarResponse barResponse = BarResponse.CreateBuilder().Build();
IRpcController controller = mocks.StrictMock<IRpcController>();
bool barCalled = false;
TestService service = new TestServiceImpl(null, (request, responseAction) => {
Assert.AreSame(barRequest, request);
barCalled = true;
responseAction(barResponse);
}, controller);
bool doneHandlerCalled = false;
Action<IMessage> doneHandler = (response => {
Assert.AreSame(barResponse, response);
doneHandlerCalled = true;
});
using (mocks.Record()) {
// No mock interactions to record
}
service.CallMethod(BarDescriptor, controller, barRequest, doneHandler);
Assert.IsTrue(doneHandlerCalled);
Assert.IsTrue(barCalled);
mocks.VerifyAll();
}
class TestServiceImpl : TestService {
private readonly Action<FooRequest, Action<FooResponse>> fooHandler;
private readonly Action<BarRequest, Action<BarResponse>> barHandler;
private readonly IRpcController expectedController;
internal TestServiceImpl() {
}
internal TestServiceImpl(Action<FooRequest, Action<FooResponse>> fooHandler,
Action<BarRequest, Action<BarResponse>> barHandler,
IRpcController expectedController) {
this.fooHandler = fooHandler;
this.barHandler = barHandler;
this.expectedController = expectedController;
}
public override void Foo(IRpcController controller, FooRequest request, Action<FooResponse> done) {
Assert.AreSame(expectedController, controller);
fooHandler(request, done);
}
public override void Bar(IRpcController controller, BarRequest request, Action<BarResponse> done) {
Assert.AreSame(expectedController, controller);
barHandler(request, done);
}
}
}
}

14
csharp/ProtocolBuffers.Test/TestProtos/EnumWithNoOuter.cs
View file

@ -1,14 +0,0 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.TestProtos {
public enum EnumWithNoOuter {
FOO = 1,
BAR = 2,
}
}

398
csharp/ProtocolBuffers.Test/TestProtos/MessageWithNoOuter.cs
View file

@ -1,398 +0,0 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.TestProtos {
public sealed partial class MessageWithNoOuter : pb::GeneratedMessage<MessageWithNoOuter, MessageWithNoOuter.Builder> {
private static readonly MessageWithNoOuter defaultInstance = new Builder().BuildPartial();
public static MessageWithNoOuter DefaultInstance {
get { return defaultInstance; }
}
public override MessageWithNoOuter DefaultInstanceForType {
get { return defaultInstance; }
}
protected override MessageWithNoOuter ThisMessage {
get { return this; }
}
public static pbd::MessageDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.TestProtos.MultiFileProto.internal__static_protobuf_unittest_MessageWithNoOuter__Descriptor; }
}
protected override pb::FieldAccess.FieldAccessorTable<MessageWithNoOuter, MessageWithNoOuter.Builder> InternalFieldAccessors {
get { return global::Google.ProtocolBuffers.TestProtos.MultiFileProto.internal__static_protobuf_unittest_MessageWithNoOuter__FieldAccessorTable; }
}
#region Nested types
public static class Types {
public enum NestedEnum {
BAZ = 3,
}
public sealed partial class NestedMessage : pb::GeneratedMessage<NestedMessage, NestedMessage.Builder> {
private static readonly NestedMessage defaultInstance = new Builder().BuildPartial();
public static NestedMessage DefaultInstance {
get { return defaultInstance; }
}
public override NestedMessage DefaultInstanceForType {
get { return defaultInstance; }
}
protected override NestedMessage ThisMessage {
get { return this; }
}
public static pbd::MessageDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.TestProtos.MultiFileProto.internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__Descriptor; }
}
protected override pb::FieldAccess.FieldAccessorTable<NestedMessage, NestedMessage.Builder> InternalFieldAccessors {
get { return global::Google.ProtocolBuffers.TestProtos.MultiFileProto.internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__FieldAccessorTable; }
}
// optional int32 i = 1;
private bool hasI;
private int i_ = 0;
public bool HasI {
get { return hasI; }
}
public int I {
get { return i_; }
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage ParseFrom(pb::ByteString data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage ParseFrom(pb::ByteString data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage ParseFrom(byte[] data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage ParseFrom(byte[] data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage ParseFrom(global::System.IO.Stream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage ParseFrom(
global::System.IO.Stream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage ParseFrom(pb::CodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage ParseFrom(pb::CodedInputStream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static Builder CreateBuilder() { return new Builder(); }
public override Builder CreateBuilderForType() { return new Builder(); }
public static Builder CreateBuilder(global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage prototype) {
return (Builder) new Builder().MergeFrom(prototype);
}
public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
// Construct using global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.CreateBuilder()
public Builder() {}
global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage result = new global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage();
protected override global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage MessageBeingBuilt {
get { return result; }
}
public override Builder Clear() {
result = new global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage();
return this;
}
public override Builder Clone() {
return new Builder().MergeFrom(result);
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.Descriptor; }
}
public override global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.DefaultInstance; }
}
public override global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage BuildPartial() {
global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage returnMe = result;
result = null;
return returnMe;
}
// optional int32 i = 1;
public bool HasI {
get { return result.HasI; }
}
public int I {
get { return result.I; }
set { SetI(value); }
}
public Builder SetI(int value) {
result.hasI = true;
result.i_ = value;
return this;
}
public Builder ClearI() {
result.hasI = false;
result.i_ = 0;
return this;
}
}
}
}
#endregion
// optional .protobuf_unittest.MessageWithNoOuter.NestedMessage nested = 1;
private bool hasNested;
private global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage nested_ = global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.DefaultInstance;
public bool HasNested {
get { return hasNested; }
}
public global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage Nested {
get { return nested_; }
}
// repeated .protobuf_unittest.TestAllTypes foreign = 2;
private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes> foreign_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes>();
public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes> ForeignList {
get { return foreign_; }
}
public int ForeignCount
{ get { return foreign_.Count; }
}
public global::Google.ProtocolBuffers.TestProtos.TestAllTypes GetForeign(int index) {
return foreign_ [index];
}
// optional .protobuf_unittest.MessageWithNoOuter.NestedEnum nested_enum = 3;
private bool hasNestedEnum;
private global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedEnum nestedEnum_ = global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedEnum.BAZ;
public bool HasNestedEnum {
get { return hasNestedEnum; }
}
public global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedEnum NestedEnum { get { return nestedEnum_; }}
// optional .protobuf_unittest.EnumWithNoOuter foreign_enum = 4;
private bool hasForeignEnum;
private global::Google.ProtocolBuffers.TestProtos.EnumWithNoOuter foreignEnum_ = global::Google.ProtocolBuffers.TestProtos.EnumWithNoOuter.FOO;
public bool HasForeignEnum {
get { return hasForeignEnum; }
}
public global::Google.ProtocolBuffers.TestProtos.EnumWithNoOuter ForeignEnum { get { return foreignEnum_; }}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter ParseFrom(pb::ByteString data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter ParseFrom(pb::ByteString data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter ParseFrom(byte[] data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter ParseFrom(byte[] data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter ParseFrom(global::System.IO.Stream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter ParseFrom(
global::System.IO.Stream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter ParseFrom(pb::CodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter ParseFrom(pb::CodedInputStream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static Builder CreateBuilder() { return new Builder(); }
public override Builder CreateBuilderForType() { return new Builder(); }
public static Builder CreateBuilder(global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter prototype) {
return (Builder) new Builder().MergeFrom(prototype);
}
public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
// Construct using global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.CreateBuilder()
public Builder() {}
global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter result = new global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter();
protected override global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter MessageBeingBuilt {
get { return result; }
}
public override Builder Clear() {
result = new global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter();
return this;
}
public override Builder Clone() {
return new Builder().MergeFrom(result);
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Descriptor; }
}
public override global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.DefaultInstance; }
}
public override global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter BuildPartial() {
result.foreign_.MakeReadOnly();
global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter returnMe = result;
result = null;
return returnMe;
}
// optional .protobuf_unittest.MessageWithNoOuter.NestedMessage nested = 1;
public bool HasNested {
get { return result.HasNested; }
}
public global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage Nested {
get { return result.Nested; }
set { SetNested(value); }
}
public Builder SetNested(global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage value) {
result.hasNested = true;
result.nested_ = value;
return this;
}
public Builder SetNested(global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.Builder builderForValue) {
result.hasNested = true;
result.nested_ = builderForValue.Build();
return this;
}
public Builder MergeNested(global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage value) {
if (result.HasNested &&
result.nested_ != global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.DefaultInstance) {
result.nested_ =
global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.CreateBuilder(result.nested_).MergeFrom(value).BuildPartial();
} else {
result.nested_ = value;
}
result.hasNested = true;
return this;
}
public Builder ClearNested() {
result.hasNested = false;
result.nested_ = global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.DefaultInstance;
return this;
}
// repeated .protobuf_unittest.TestAllTypes foreign = 2;
public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes> ForeignList {
get { return result.foreign_; }
}
public int ForeignCount {
get { return result.ForeignCount; }
}
public global::Google.ProtocolBuffers.TestProtos.TestAllTypes GetForeign(int index) {
return result.GetForeign(index);
}
public Builder SetForeign(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes value) {
result.foreign_[index] = value;
return this;
}
public Builder SetForeign(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Builder builderForValue) {
result.foreign_[index] = builderForValue.Build();
return this;
}
public Builder AddForeign(global::Google.ProtocolBuffers.TestProtos.TestAllTypes value) {
result.foreign_.Add(value);
return this;
}
public Builder AddForeign(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Builder builderForValue) {
result.foreign_.Add(builderForValue.Build());
return this;
}
public Builder AddRangeForeign(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes> values) {
base.AddRange(values, result.foreign_);
return this;
}
public Builder ClearForeign() {
result.foreign_.Clear();
return this;
}
// optional .protobuf_unittest.MessageWithNoOuter.NestedEnum nested_enum = 3;
public bool HasNestedEnum {
get { return result.HasNestedEnum; }
}
public global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedEnum NestedEnum {
get { return result.NestedEnum; }
set { SetNestedEnum(value); }
}
public Builder SetNestedEnum(global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedEnum value) {
result.hasNestedEnum = true;
result.nestedEnum_ = value;
return this;
}
public Builder ClearNestedEnum() {
result.hasNestedEnum = false;
result.nestedEnum_ = global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedEnum.BAZ;
return this;
}
// optional .protobuf_unittest.EnumWithNoOuter foreign_enum = 4;
public bool HasForeignEnum {
get { return result.HasForeignEnum; }
}
public global::Google.ProtocolBuffers.TestProtos.EnumWithNoOuter ForeignEnum {
get { return result.ForeignEnum; }
set { SetForeignEnum(value); }
}
public Builder SetForeignEnum(global::Google.ProtocolBuffers.TestProtos.EnumWithNoOuter value) {
result.hasForeignEnum = true;
result.foreignEnum_ = value;
return this;
}
public Builder ClearForeignEnum() {
result.hasForeignEnum = false;
result.foreignEnum_ = global::Google.ProtocolBuffers.TestProtos.EnumWithNoOuter.FOO;
return this;
}
}
}
}

79
csharp/ProtocolBuffers.Test/TestProtos/MultiFileProto.cs
View file

@ -1,79 +0,0 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.TestProtos {
public static partial class MultiFileProto {
#region Descriptor
public static pbd::FileDescriptor Descriptor {
get { return descriptor; }
}
private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom (
new byte[] {
0x0a, 0x3b, 0x73, 0x72, 0x63, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x2f, 0x63, 0x6f, 0x6d, 0x2f,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x6d, 0x75, 0x6c, 0x74,
0x69, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x12, 0x11, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74,
0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x75, 0x6e,
0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xbf, 0x02, 0x0a, 0x12, 0x4d, 0x65, 0x73,
0x73, 0x61, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x43, 0x0a, 0x06, 0x6e,
0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x57,
0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73,
0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x07, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x1f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73,
0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x45, 0x0a, 0x0b, 0x6e, 0x65,
0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x30, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73,
0x61, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65,
0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x38, 0x0a, 0x0c, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75,
0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75,
0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75,
0x74, 0x65, 0x72, 0x1a, 0x1a, 0x0a, 0x0d, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
0x12, 0x09, 0x0a, 0x01, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x22, 0x15, 0x0a, 0x0a, 0x4e, 0x65, 0x73, 0x74, 0x65,
0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x5a, 0x10, 0x03, 0x2a, 0x23, 0x0a, 0x0f, 0x45, 0x6e,
0x75, 0x6d, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x07, 0x0a, 0x03, 0x46, 0x4f, 0x4f,
0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x52, 0x10, 0x02, 0x32, 0x63, 0x0a, 0x12, 0x53, 0x65, 0x72, 0x76, 0x69,
0x63, 0x65, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x4d, 0x0a, 0x03, 0x46, 0x6f, 0x6f,
0x12, 0x25, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74,
0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x1a,
0x1f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e,
0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x3a, 0x44, 0x0a, 0x14, 0x65, 0x78, 0x74, 0x65,
0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x24, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73,
0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x87, 0xad, 0x4b, 0x20, 0x01,
0x28, 0x05, 0x42, 0x58, 0x42, 0x16, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x54,
0x65, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0xc2, 0x3e, 0x21, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x2e, 0x54, 0x65, 0x73, 0x74,
0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0xca, 0x3e, 0x0e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x46, 0x69, 0x6c, 0x65, 0x50, 0x72,
0x6f, 0x74, 0x6f, 0xd0, 0x3e, 0x01, 0xd8, 0x3e, 0x00, 0xe0, 0x3e, 0x01,
}, new pbd::FileDescriptor[] {
global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.Descriptor,
});
#endregion
#region Extensions
public static readonly pb::GeneratedExtensionBase<int> ExtensionWithOuter =
pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[0]);
#endregion
#region Static variables
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_MessageWithNoOuter__Descriptor
= Descriptor.MessageTypes[0];
internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter, global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Builder> internal__static_protobuf_unittest_MessageWithNoOuter__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter, global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Builder>(internal__static_protobuf_unittest_MessageWithNoOuter__Descriptor,
new string[] { "Nested", "Foreign", "NestedEnum", "ForeignEnum", });
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__Descriptor
= internal__static_protobuf_unittest_MessageWithNoOuter__Descriptor.NestedTypes[0];
internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage, global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.Builder> internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage, global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.Types.NestedMessage.Builder>(internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__Descriptor,
new string[] { "I", });
#endregion
}
}

101
csharp/ProtocolBuffers.Test/TestProtos/ServiceWithNoOuter.cs
View file

@ -1,101 +0,0 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.TestProtos {
public abstract class ServiceWithNoOuter : pb::IService {
public abstract void Foo(
pb::IRpcController controller,
global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter request,
global::System.Action<global::Google.ProtocolBuffers.TestProtos.TestAllTypes> done);
public static pbd::ServiceDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.TestProtos.MultiFileProto.Descriptor.Services[0]; }
}
public pbd::ServiceDescriptor DescriptorForType {
get { return Descriptor; }
}
public void CallMethod(
pbd::MethodDescriptor method,
pb::IRpcController controller,
pb::IMessage request,
global::System.Action<pb::IMessage> done) {
if (method.Service != Descriptor) {
throw new global::System.ArgumentException(
"Service.CallMethod() given method descriptor for wrong " +
"service type.");
}
switch(method.Index) {
case 0:
this.Foo(controller, (global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter)request,
pb::RpcUtil.SpecializeCallback<global::Google.ProtocolBuffers.TestProtos.TestAllTypes>(
done));
return;
default:
throw new global::System.InvalidOperationException("Can't get here.");
}
}
public pb::IMessage GetRequestPrototype(pbd::MethodDescriptor method) {
if (method.Service != Descriptor) {
throw new global::System.ArgumentException(
"Service.GetRequestPrototype() given method " +
"descriptor for wrong service type.");
}
switch(method.Index) {
case 0:
return global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter.DefaultInstance;
default:
throw new global::System.ArgumentException("Can't get here.");
}
}
public pb::IMessage GetResponsePrototype(pbd::MethodDescriptor method) {
if (method.Service != Descriptor) {
throw new global::System.ArgumentException(
"Service.GetResponsePrototype() given method " +
"descriptor for wrong service type.");
}
switch(method.Index) {
case 0:
return global::Google.ProtocolBuffers.TestProtos.TestAllTypes.DefaultInstance;
default:
throw new global::System.ArgumentException("Can't get here.");
}
}
public static Stub CreateStub(
pb::IRpcChannel channel) {
return new Stub(channel);
}
public class Stub : global::Google.ProtocolBuffers.TestProtos.ServiceWithNoOuter {
internal Stub(pb::IRpcChannel channel) {
this.channel = channel;
}
private readonly pb::IRpcChannel channel;
public pb::IRpcChannel Channel {
get { return channel; }
}
public override void Foo(
pb::IRpcController controller,
global::Google.ProtocolBuffers.TestProtos.MessageWithNoOuter request,
global::System.Action<global::Google.ProtocolBuffers.TestProtos.TestAllTypes> done) {
channel.CallMethod(
Descriptor.Methods[0],
controller,
request,
global::Google.ProtocolBuffers.TestProtos.TestAllTypes.DefaultInstance,
pb::RpcUtil.GeneralizeCallback<global::Google.ProtocolBuffers.TestProtos.TestAllTypes, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Builder>(done, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.DefaultInstance));
}
}
}
}

358
csharp/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs
View file

@ -1,358 +0,0 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.TestProtos {
public static partial class UnitTestEmbedOptimizeForProtoFile {
#region Descriptor
public static pbd::FileDescriptor Descriptor {
get { return descriptor; }
}
private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom (
new byte[] {
0x0a, 0x31, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x75, 0x6e,
0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x65, 0x6d, 0x62, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a,
0x65, 0x5f, 0x66, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6f, 0x70, 0x74,
0x69, 0x6d, 0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa1, 0x01, 0x0a, 0x19,
0x54, 0x65, 0x73, 0x74, 0x45, 0x6d, 0x62, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6f,
0x72, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x41, 0x0a, 0x10, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6d, 0x65,
0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69,
0x6d, 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x41, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65,
0x61, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54,
0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x53, 0x69, 0x7a, 0x65, 0x42,
0x4a, 0x48, 0x01, 0xc2, 0x3e, 0x21, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
0x6c, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0xca,
0x3e, 0x21, 0x55, 0x6e, 0x69, 0x74, 0x54, 0x65, 0x73, 0x74, 0x45, 0x6d, 0x62, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6d,
0x69, 0x7a, 0x65, 0x46, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x46, 0x69, 0x6c, 0x65,
}, new pbd::FileDescriptor[] {
global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.Descriptor,
});
#endregion
#region Extensions
#endregion
#region Static variables
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestEmbedOptimizedForSize__Descriptor
= Descriptor.MessageTypes[0];
internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize.Builder> internal__static_protobuf_unittest_TestEmbedOptimizedForSize__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize.Builder>(internal__static_protobuf_unittest_TestEmbedOptimizedForSize__Descriptor,
new string[] { "OptionalMessage", "RepeatedMessage", });
#endregion
}
#region Enums
#endregion
#region Messages
public sealed partial class TestEmbedOptimizedForSize : pb::GeneratedMessage<TestEmbedOptimizedForSize, TestEmbedOptimizedForSize.Builder> {
private static readonly TestEmbedOptimizedForSize defaultInstance = new Builder().BuildPartial();
public static TestEmbedOptimizedForSize DefaultInstance {
get { return defaultInstance; }
}
public override TestEmbedOptimizedForSize DefaultInstanceForType {
get { return defaultInstance; }
}
protected override TestEmbedOptimizedForSize ThisMessage {
get { return this; }
}
public static pbd::MessageDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestEmbedOptimizeForProtoFile.internal__static_protobuf_unittest_TestEmbedOptimizedForSize__Descriptor; }
}
protected override pb::FieldAccess.FieldAccessorTable<TestEmbedOptimizedForSize, TestEmbedOptimizedForSize.Builder> InternalFieldAccessors {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestEmbedOptimizeForProtoFile.internal__static_protobuf_unittest_TestEmbedOptimizedForSize__FieldAccessorTable; }
}
// optional .protobuf_unittest.TestOptimizedForSize optional_message = 1;
private bool hasOptionalMessage;
private global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance;
public bool HasOptionalMessage {
get { return hasOptionalMessage; }
}
public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize OptionalMessage {
get { return optionalMessage_; }
}
// repeated .protobuf_unittest.TestOptimizedForSize repeated_message = 2;
private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize> repeatedMessage_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize>();
public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize> RepeatedMessageList {
get { return repeatedMessage_; }
}
public int RepeatedMessageCount
{ get { return repeatedMessage_.Count; }
}
public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize GetRepeatedMessage(int index) {
return repeatedMessage_ [index];
}
public override bool IsInitialized {
get {
if (HasOptionalMessage) {
if (!OptionalMessage.IsInitialized) return false;
}
foreach (global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize element in RepeatedMessageList) {
if (!element.IsInitialized) return false;
}
return true;
}
}
public override void WriteTo(pb::CodedOutputStream output) {
if (HasOptionalMessage) {
output.WriteMessage(1, OptionalMessage);
}
foreach (global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize element in RepeatedMessageList) {
output.WriteMessage(2, element);
}
UnknownFields.WriteTo(output);
}
private int memoizedSerializedSize = -1;
public override int SerializedSize {
get {
int size = memoizedSerializedSize;
if (size != -1) return size;
size = 0;
if (HasOptionalMessage) {
size += pb::CodedOutputStream.ComputeMessageSize(1, OptionalMessage);
}
foreach (global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize element in RepeatedMessageList) {
size += pb::CodedOutputStream.ComputeMessageSize(2, element);
}
size += UnknownFields.SerializedSize;
memoizedSerializedSize = size;
return size;
}
}
public static global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize ParseFrom(pb::ByteString data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize ParseFrom(pb::ByteString data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize ParseFrom(byte[] data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize ParseFrom(byte[] data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize ParseFrom(global::System.IO.Stream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize ParseFrom(
global::System.IO.Stream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize ParseFrom(pb::CodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize ParseFrom(pb::CodedInputStream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static Builder CreateBuilder() { return new Builder(); }
public override Builder CreateBuilderForType() { return new Builder(); }
public static Builder CreateBuilder(global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize prototype) {
return (Builder) new Builder().MergeFrom(prototype);
}
public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
// Construct using global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize.CreateBuilder()
public Builder() {}
global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize result = new global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize();
protected override global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize MessageBeingBuilt {
get { return result; }
}
public override Builder Clear() {
result = new global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize();
return this;
}
public override Builder Clone() {
return new Builder().MergeFrom(result);
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize.Descriptor; }
}
public override global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize.DefaultInstance; }
}
public override global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize BuildPartial() {
result.repeatedMessage_.MakeReadOnly();
global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize returnMe = result;
result = null;
return returnMe;
}
public override Builder MergeFrom(pb::IMessage other) {
if (other is global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize) {
return MergeFrom((global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize) other);
} else {
base.MergeFrom(other);
return this;
}
}
public override Builder MergeFrom(global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize other) {
if (other == global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize.DefaultInstance) return this;
if (other.HasOptionalMessage) {
MergeOptionalMessage(other.OptionalMessage);
}
if (other.repeatedMessage_.Count != 0) {
base.AddRange(other.repeatedMessage_, result.repeatedMessage_);
}
this.MergeUnknownFields(other.UnknownFields);
return this;
}
public override Builder MergeFrom(pb::CodedInputStream input) {
return MergeFrom(input, pb::ExtensionRegistry.Empty);
}
public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
pb::UnknownFieldSet.Builder unknownFields =
pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
while (true) {
uint tag = input.ReadTag();
switch (tag) {
case 0:
this.UnknownFields = unknownFields.Build();
return this;
default: {
if (!ParseUnknownField(input, unknownFields,
extensionRegistry, tag)) {
this.UnknownFields = unknownFields.Build();
return this;
}
break;
}
case 10: {
global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder();
if (HasOptionalMessage) {
subBuilder.MergeFrom(OptionalMessage);
}
input.ReadMessage(subBuilder, extensionRegistry);
OptionalMessage = subBuilder.BuildPartial();
break;
}
case 18: {
global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder();
input.ReadMessage(subBuilder, extensionRegistry);
AddRepeatedMessage(subBuilder.BuildPartial());
break;
}
}
}
}
// optional .protobuf_unittest.TestOptimizedForSize optional_message = 1;
public bool HasOptionalMessage {
get { return result.HasOptionalMessage; }
}
public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize OptionalMessage {
get { return result.OptionalMessage; }
set { SetOptionalMessage(value); }
}
public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) {
result.hasOptionalMessage = true;
result.optionalMessage_ = value;
return this;
}
public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder builderForValue) {
result.hasOptionalMessage = true;
result.optionalMessage_ = builderForValue.Build();
return this;
}
public Builder MergeOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) {
if (result.HasOptionalMessage &&
result.optionalMessage_ != global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance) {
result.optionalMessage_ =
global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder(result.optionalMessage_).MergeFrom(value).BuildPartial();
} else {
result.optionalMessage_ = value;
}
result.hasOptionalMessage = true;
return this;
}
public Builder ClearOptionalMessage() {
result.hasOptionalMessage = false;
result.optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance;
return this;
}
// repeated .protobuf_unittest.TestOptimizedForSize repeated_message = 2;
public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize> RepeatedMessageList {
get { return result.repeatedMessage_; }
}
public int RepeatedMessageCount {
get { return result.RepeatedMessageCount; }
}
public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize GetRepeatedMessage(int index) {
return result.GetRepeatedMessage(index);
}
public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) {
result.repeatedMessage_[index] = value;
return this;
}
public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder builderForValue) {
result.repeatedMessage_[index] = builderForValue.Build();
return this;
}
public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) {
result.repeatedMessage_.Add(value);
return this;
}
public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder builderForValue) {
result.repeatedMessage_.Add(builderForValue.Build());
return this;
}
public Builder AddRangeRepeatedMessage(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize> values) {
base.AddRange(values, result.repeatedMessage_);
return this;
}
public Builder ClearRepeatedMessage() {
result.repeatedMessage_.Clear();
return this;
}
}
}
#endregion
#region Services
#endregion
}

242
csharp/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs
View file

@ -1,242 +0,0 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.TestProtos {
public static partial class UnitTestImportProtoFile {
#region Descriptor
public static pbd::FileDescriptor Descriptor {
get { return descriptor; }
}
private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom(
global::System.Convert.FromBase64String(
"ChV1bml0dGVzdF9pbXBvcnQucHJvdG8SGHByb3RvYnVmX3VuaXR0ZXN0X2lt" +
"cG9ydBokZ29vZ2xlL3Byb3RvYnVmL2NzaGFycF9vcHRpb25zLnByb3RvGiBn" +
"b29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90byIaCg1JbXBvcnRNZXNz" +
"YWdlEgkKAWQYASABKAUqPAoKSW1wb3J0RW51bRIOCgpJTVBPUlRfRk9PEAcS" +
"DgoKSU1QT1JUX0JBUhAIEg4KCklNUE9SVF9CQVoQCUJcChhjb20uZ29vZ2xl" +
"LnByb3RvYnVmLnRlc3RIAYLiCSFHb29nbGUuUHJvdG9jb2xCdWZmZXJzLlRl" +
"c3RQcm90b3OK4gkXVW5pdFRlc3RJbXBvcnRQcm90b0ZpbGU="),
new pbd::FileDescriptor[] {
global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor,
global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor,
});
#endregion
#region Static variables
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_import_ImportMessage__Descriptor
= Descriptor.MessageTypes[0];
internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ImportMessage, global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder> internal__static_protobuf_unittest_import_ImportMessage__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ImportMessage, global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder>(internal__static_protobuf_unittest_import_ImportMessage__Descriptor,
new string[] { "D", });
#endregion
}
#region Enums
public enum ImportEnum {
IMPORT_FOO = 7,
IMPORT_BAR = 8,
IMPORT_BAZ = 9,
}
#endregion
#region Messages
public sealed partial class ImportMessage : pb::GeneratedMessage<ImportMessage, ImportMessage.Builder> {
private static readonly ImportMessage defaultInstance = new Builder().BuildPartial();
public static ImportMessage DefaultInstance {
get { return defaultInstance; }
}
public override ImportMessage DefaultInstanceForType {
get { return defaultInstance; }
}
protected override ImportMessage ThisMessage {
get { return this; }
}
public static pbd::MessageDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.internal__static_protobuf_unittest_import_ImportMessage__Descriptor; }
}
protected override pb::FieldAccess.FieldAccessorTable<ImportMessage, ImportMessage.Builder> InternalFieldAccessors {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.internal__static_protobuf_unittest_import_ImportMessage__FieldAccessorTable; }
}
private bool hasD;
private int d_ = 0;
public bool HasD {
get { return hasD; }
}
public int D {
get { return d_; }
}
public override bool IsInitialized {
get {
return true;
}
}
public override void WriteTo(pb::CodedOutputStream output) {
if (HasD) {
output.WriteInt32(1, D);
}
UnknownFields.WriteTo(output);
}
private int memoizedSerializedSize = -1;
public override int SerializedSize {
get {
int size = memoizedSerializedSize;
if (size != -1) return size;
size = 0;
if (HasD) {
size += pb::CodedOutputStream.ComputeInt32Size(1, D);
}
size += UnknownFields.SerializedSize;
memoizedSerializedSize = size;
return size;
}
}
public static ImportMessage ParseFrom(pb::ByteString data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static ImportMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
}
public static ImportMessage ParseFrom(byte[] data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static ImportMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
}
public static ImportMessage ParseFrom(global::System.IO.Stream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static ImportMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
}
public static ImportMessage ParseFrom(pb::CodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static ImportMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
}
public static Builder CreateBuilder() { return new Builder(); }
public override Builder CreateBuilderForType() { return new Builder(); }
public static Builder CreateBuilder(ImportMessage prototype) {
return (Builder) new Builder().MergeFrom(prototype);
}
public sealed partial class Builder : pb::GeneratedBuilder<ImportMessage, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
public Builder() {}
ImportMessage result = new ImportMessage();
protected override ImportMessage MessageBeingBuilt {
get { return result; }
}
public override Builder Clear() {
result = new ImportMessage();
return this;
}
public override Builder Clone() {
return new Builder().MergeFrom(result);
}
public override pbd::MessageDescriptor DescriptorForType {
get { return ImportMessage.Descriptor; }
}
public override ImportMessage DefaultInstanceForType {
get { return ImportMessage.DefaultInstance; }
}
public override ImportMessage BuildPartial() {
ImportMessage returnMe = result;
result = null;
return returnMe;
}
public override Builder MergeFrom(pb::IMessage other) {
if (other is ImportMessage) {
return MergeFrom((ImportMessage) other);
} else {
base.MergeFrom(other);
return this;
}
}
public override Builder MergeFrom(ImportMessage other) {
if (other == ImportMessage.DefaultInstance) return this;
if (other.HasD) {
D = other.D;
}
this.MergeUnknownFields(other.UnknownFields);
return this;
}
public override Builder MergeFrom(pb::CodedInputStream input) {
return MergeFrom(input, pb::ExtensionRegistry.Empty);
}
public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
while (true) {
uint tag = input.ReadTag();
switch (tag) {
case 0: {
this.UnknownFields = unknownFields.Build();
return this;
}
default: {
if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
this.UnknownFields = unknownFields.Build();
return this;
}
break;
}
case 8: {
D = input.ReadInt32();
break;
}
}
}
}
public bool HasD {
get { return result.HasD; }
}
public int D {
get { return result.D; }
set { SetD(value); }
}
public Builder SetD(int value) {
result.hasD = true;
result.d_ = value;
return this;
}
public Builder ClearD() {
result.hasD = false;
result.d_ = 0;
return this;
}
}
}
#endregion
}

1416
csharp/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs
View file

File diff suppressed because it is too large Load diff

538
csharp/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs
View file

@ -1,538 +0,0 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.TestProtos {
public static partial class UnitTestOptimizeForProtoFile {
#region Descriptor
public static pbd::FileDescriptor Descriptor {
get { return descriptor; }
}
private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom (
new byte[] {
0x0a, 0x2b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x75, 0x6e,
0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74,
0x74, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x9e, 0x01, 0x0a,
0x14, 0x54, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x53, 0x69, 0x7a,
0x65, 0x12, 0x09, 0x0a, 0x01, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x12, 0x2e, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18,
0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69,
0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x46, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x32, 0x40, 0x0a, 0x0e, 0x74, 0x65, 0x73, 0x74, 0x5f,
0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69,
0x7a, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x53, 0x69, 0x7a, 0x65, 0x18, 0xd2, 0x09, 0x20, 0x01, 0x28, 0x05, 0x22, 0x29, 0x0a,
0x1c, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a,
0x65, 0x64, 0x46, 0x6f, 0x72, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x09, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x02, 0x28, 0x05,
0x22, 0x5a, 0x0a, 0x1c, 0x54, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4f, 0x70, 0x74, 0x69,
0x6d, 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x3a, 0x0a, 0x01, 0x6f, 0x18, 0x01, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74,
0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69,
0x6d, 0x69, 0x7a, 0x65, 0x64, 0x46, 0x6f, 0x72, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x45, 0x48, 0x02, 0xc2, 0x3e, 0x21, 0x47,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72,
0x73, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0xca, 0x3e, 0x1c, 0x55, 0x6e, 0x69, 0x74, 0x54,
0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x46, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x46,
0x69, 0x6c, 0x65,
}, new pbd::FileDescriptor[] {
global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.Descriptor,
});
#endregion
#region Extensions
#endregion
#region Static variables
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestOptimizedForSize__Descriptor
= Descriptor.MessageTypes[0];
internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder> internal__static_protobuf_unittest_TestOptimizedForSize__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder>(internal__static_protobuf_unittest_TestOptimizedForSize__Descriptor,
new string[] { "I", "Msg", });
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestRequiredOptimizedForSize__Descriptor
= Descriptor.MessageTypes[1];
internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.Builder> internal__static_protobuf_unittest_TestRequiredOptimizedForSize__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.Builder>(internal__static_protobuf_unittest_TestRequiredOptimizedForSize__Descriptor,
new string[] { "X", });
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestOptionalOptimizedForSize__Descriptor
= Descriptor.MessageTypes[2];
internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize.Builder> internal__static_protobuf_unittest_TestOptionalOptimizedForSize__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize.Builder>(internal__static_protobuf_unittest_TestOptionalOptimizedForSize__Descriptor,
new string[] { "O", });
#endregion
}
#region Enums
#endregion
#region Messages
public sealed partial class TestOptimizedForSize : pb::ExtendableMessage<TestOptimizedForSize, TestOptimizedForSize.Builder> {
private static readonly TestOptimizedForSize defaultInstance = new Builder().BuildPartial();
public static TestOptimizedForSize DefaultInstance {
get { return defaultInstance; }
}
public override TestOptimizedForSize DefaultInstanceForType {
get { return defaultInstance; }
}
protected override TestOptimizedForSize ThisMessage {
get { return this; }
}
public static pbd::MessageDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptimizedForSize__Descriptor; }
}
protected override pb::FieldAccess.FieldAccessorTable<TestOptimizedForSize, TestOptimizedForSize.Builder> InternalFieldAccessors {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptimizedForSize__FieldAccessorTable; }
}
public static readonly pb::GeneratedExtensionBase<int> TestExtension =
pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[0]);
#region Nested types
public static class Types {
}
#endregion
// optional int32 i = 1;
private bool hasI;
private int i_ = 0;
public bool HasI {
get { return hasI; }
}
public int I {
get { return i_; }
}
// optional .protobuf_unittest.ForeignMessage msg = 19;
private bool hasMsg;
private global::Google.ProtocolBuffers.TestProtos.ForeignMessage msg_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance;
public bool HasMsg {
get { return hasMsg; }
}
public global::Google.ProtocolBuffers.TestProtos.ForeignMessage Msg {
get { return msg_; }
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize ParseFrom(pb::ByteString data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize ParseFrom(pb::ByteString data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize ParseFrom(byte[] data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize ParseFrom(byte[] data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize ParseFrom(global::System.IO.Stream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize ParseFrom(
global::System.IO.Stream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize ParseFrom(pb::CodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize ParseFrom(pb::CodedInputStream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static Builder CreateBuilder() { return new Builder(); }
public override Builder CreateBuilderForType() { return new Builder(); }
public static Builder CreateBuilder(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize prototype) {
return (Builder) new Builder().MergeFrom(prototype);
}
public sealed partial class Builder : pb::ExtendableBuilder<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
// Construct using global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder()
public Builder() {}
global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize result = new global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize();
protected override global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize MessageBeingBuilt {
get { return result; }
}
public override Builder Clear() {
result = new global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize();
return this;
}
public override Builder Clone() {
return new Builder().MergeFrom(result);
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Descriptor; }
}
public override global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance; }
}
public override global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize BuildPartial() {
global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize returnMe = result;
result = null;
return returnMe;
}
// optional int32 i = 1;
public bool HasI {
get { return result.HasI; }
}
public int I {
get { return result.I; }
set { SetI(value); }
}
public Builder SetI(int value) {
result.hasI = true;
result.i_ = value;
return this;
}
public Builder ClearI() {
result.hasI = false;
result.i_ = 0;
return this;
}
// optional .protobuf_unittest.ForeignMessage msg = 19;
public bool HasMsg {
get { return result.HasMsg; }
}
public global::Google.ProtocolBuffers.TestProtos.ForeignMessage Msg {
get { return result.Msg; }
set { SetMsg(value); }
}
public Builder SetMsg(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) {
result.hasMsg = true;
result.msg_ = value;
return this;
}
public Builder SetMsg(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) {
result.hasMsg = true;
result.msg_ = builderForValue.Build();
return this;
}
public Builder MergeMsg(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) {
if (result.HasMsg &&
result.msg_ != global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance) {
result.msg_ =
global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(result.msg_).MergeFrom(value).BuildPartial();
} else {
result.msg_ = value;
}
result.hasMsg = true;
return this;
}
public Builder ClearMsg() {
result.hasMsg = false;
result.msg_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance;
return this;
}
}
}
public sealed partial class TestRequiredOptimizedForSize : pb::GeneratedMessage<TestRequiredOptimizedForSize, TestRequiredOptimizedForSize.Builder> {
private static readonly TestRequiredOptimizedForSize defaultInstance = new Builder().BuildPartial();
public static TestRequiredOptimizedForSize DefaultInstance {
get { return defaultInstance; }
}
public override TestRequiredOptimizedForSize DefaultInstanceForType {
get { return defaultInstance; }
}
protected override TestRequiredOptimizedForSize ThisMessage {
get { return this; }
}
public static pbd::MessageDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestRequiredOptimizedForSize__Descriptor; }
}
protected override pb::FieldAccess.FieldAccessorTable<TestRequiredOptimizedForSize, TestRequiredOptimizedForSize.Builder> InternalFieldAccessors {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestRequiredOptimizedForSize__FieldAccessorTable; }
}
// required int32 x = 1;
private bool hasX;
private int x_ = 0;
public bool HasX {
get { return hasX; }
}
public int X {
get { return x_; }
}
public static global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize ParseFrom(pb::ByteString data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize ParseFrom(pb::ByteString data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize ParseFrom(byte[] data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize ParseFrom(byte[] data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize ParseFrom(global::System.IO.Stream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize ParseFrom(
global::System.IO.Stream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize ParseFrom(pb::CodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize ParseFrom(pb::CodedInputStream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static Builder CreateBuilder() { return new Builder(); }
public override Builder CreateBuilderForType() { return new Builder(); }
public static Builder CreateBuilder(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize prototype) {
return (Builder) new Builder().MergeFrom(prototype);
}
public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
// Construct using global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.CreateBuilder()
public Builder() {}
global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize result = new global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize();
protected override global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize MessageBeingBuilt {
get { return result; }
}
public override Builder Clear() {
result = new global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize();
return this;
}
public override Builder Clone() {
return new Builder().MergeFrom(result);
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.Descriptor; }
}
public override global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance; }
}
public override global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize BuildPartial() {
global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize returnMe = result;
result = null;
return returnMe;
}
// required int32 x = 1;
public bool HasX {
get { return result.HasX; }
}
public int X {
get { return result.X; }
set { SetX(value); }
}
public Builder SetX(int value) {
result.hasX = true;
result.x_ = value;
return this;
}
public Builder ClearX() {
result.hasX = false;
result.x_ = 0;
return this;
}
}
}
public sealed partial class TestOptionalOptimizedForSize : pb::GeneratedMessage<TestOptionalOptimizedForSize, TestOptionalOptimizedForSize.Builder> {
private static readonly TestOptionalOptimizedForSize defaultInstance = new Builder().BuildPartial();
public static TestOptionalOptimizedForSize DefaultInstance {
get { return defaultInstance; }
}
public override TestOptionalOptimizedForSize DefaultInstanceForType {
get { return defaultInstance; }
}
protected override TestOptionalOptimizedForSize ThisMessage {
get { return this; }
}
public static pbd::MessageDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptionalOptimizedForSize__Descriptor; }
}
protected override pb::FieldAccess.FieldAccessorTable<TestOptionalOptimizedForSize, TestOptionalOptimizedForSize.Builder> InternalFieldAccessors {
get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptionalOptimizedForSize__FieldAccessorTable; }
}
// optional .protobuf_unittest.TestRequiredOptimizedForSize o = 1;
private bool hasO;
private global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize o_ = global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance;
public bool HasO {
get { return hasO; }
}
public global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize O {
get { return o_; }
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize ParseFrom(pb::ByteString data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize ParseFrom(pb::ByteString data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize ParseFrom(byte[] data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize ParseFrom(byte[] data,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize ParseFrom(global::System.IO.Stream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize ParseFrom(
global::System.IO.Stream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize ParseFrom(pb::CodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize ParseFrom(pb::CodedInputStream input,
pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
.BuildParsed();
}
public static Builder CreateBuilder() { return new Builder(); }
public override Builder CreateBuilderForType() { return new Builder(); }
public static Builder CreateBuilder(global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize prototype) {
return (Builder) new Builder().MergeFrom(prototype);
}
public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
// Construct using global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize.CreateBuilder()
public Builder() {}
global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize result = new global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize();
protected override global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize MessageBeingBuilt {
get { return result; }
}
public override Builder Clear() {
result = new global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize();
return this;
}
public override Builder Clone() {
return new Builder().MergeFrom(result);
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize.Descriptor; }
}
public override global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize.DefaultInstance; }
}
public override global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize BuildPartial() {
global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize returnMe = result;
result = null;
return returnMe;
}
// optional .protobuf_unittest.TestRequiredOptimizedForSize o = 1;
public bool HasO {
get { return result.HasO; }
}
public global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize O {
get { return result.O; }
set { SetO(value); }
}
public Builder SetO(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize value) {
result.hasO = true;
result.o_ = value;
return this;
}
public Builder SetO(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.Builder builderForValue) {
result.hasO = true;
result.o_ = builderForValue.Build();
return this;
}
public Builder MergeO(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize value) {
if (result.HasO &&
result.o_ != global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance) {
result.o_ =
global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.CreateBuilder(result.o_).MergeFrom(value).BuildPartial();
} else {
result.o_ = value;
}
result.hasO = true;
return this;
}
public Builder ClearO() {
result.hasO = false;
result.o_ = global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance;
return this;
}
}
}
#endregion
#region Services
#endregion
}

12930
csharp/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs
View file

File diff suppressed because it is too large Load diff

1371
csharp/ProtocolBuffers.Test/TestUtil.cs
View file

File diff suppressed because it is too large Load diff

487
csharp/ProtocolBuffers.Test/TextFormatTest.cs
View file

@ -1,487 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.IO;
using System.Text;
using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework;
namespace Google.ProtocolBuffers {
[TestFixture]
public class TextFormatTest {
private static readonly string AllFieldsSetText = TestUtil.ReadTextFromFile("text_format_unittest_data.txt");
private static readonly string AllExtensionsSetText = TestUtil.ReadTextFromFile("text_format_unittest_extensions_data.txt");
/// <summary>
/// Note that this is slightly different to the Java - 123.0 becomes 123, and 1.23E17 becomes 1.23E+17.
/// Both of these differences can be parsed by the Java and the C++, and we can parse their output too.
/// </summary>
private const string ExoticText =
"repeated_int32: -1\n" +
"repeated_int32: -2147483648\n" +
"repeated_int64: -1\n" +
"repeated_int64: -9223372036854775808\n" +
"repeated_uint32: 4294967295\n" +
"repeated_uint32: 2147483648\n" +
"repeated_uint64: 18446744073709551615\n" +
"repeated_uint64: 9223372036854775808\n" +
"repeated_double: 123\n" +
"repeated_double: 123.5\n" +
"repeated_double: 0.125\n" +
"repeated_double: 1.23E+17\n" +
"repeated_double: 1.235E+22\n" +
"repeated_double: 1.235E-18\n" +
"repeated_double: 123.456789\n" +
"repeated_double: Infinity\n" +
"repeated_double: -Infinity\n" +
"repeated_double: NaN\n" +
"repeated_string: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"" +
"\\341\\210\\264\"\n" +
"repeated_bytes: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"\\376\"\n";
private const string MessageSetText =
"[protobuf_unittest.TestMessageSetExtension1] {\n" +
" i: 123\n" +
"}\n" +
"[protobuf_unittest.TestMessageSetExtension2] {\n" +
" str: \"foo\"\n" +
"}\n";
/// <summary>
/// Print TestAllTypes and compare with golden file.
/// </summary>
[Test]
public void PrintMessage() {
string text = TextFormat.PrintToString(TestUtil.GetAllSet());
Assert.AreEqual(AllFieldsSetText.Replace("\r\n", "\n"), text.Replace("\r\n", "\n"));
}
/// <summary>
/// Print TestAllExtensions and compare with golden file.
/// </summary>
[Test]
public void PrintExtensions() {
string text = TextFormat.PrintToString(TestUtil.GetAllExtensionsSet());
Assert.AreEqual(AllExtensionsSetText.Replace("\r\n", "\n"), text.Replace("\r\n", "\n"));
}
/// <summary>
/// Test printing of unknown fields in a message.
/// </summary>
[Test]
public void PrintUnknownFields() {
TestEmptyMessage message =
TestEmptyMessage.CreateBuilder()
.SetUnknownFields(
UnknownFieldSet.CreateBuilder()
.AddField(5,
UnknownField.CreateBuilder()
.AddVarint(1)
.AddFixed32(2)
.AddFixed64(3)
.AddLengthDelimited(ByteString.CopyFromUtf8("4"))
.AddGroup(
UnknownFieldSet.CreateBuilder()
.AddField(10,
UnknownField.CreateBuilder()
.AddVarint(5)
.Build())
.Build())
.Build())
.AddField(8,
UnknownField.CreateBuilder()
.AddVarint(1)
.AddVarint(2)
.AddVarint(3)
.Build())
.AddField(15,
UnknownField.CreateBuilder()
.AddVarint(0xABCDEF1234567890L)
.AddFixed32(0xABCD1234)
.AddFixed64(0xABCDEF1234567890L)
.Build())
.Build())
.Build();
Assert.AreEqual(
"5: 1\n" +
"5: 0x00000002\n" +
"5: 0x0000000000000003\n" +
"5: \"4\"\n" +
"5 {\n" +
" 10: 5\n" +
"}\n" +
"8: 1\n" +
"8: 2\n" +
"8: 3\n" +
"15: 12379813812177893520\n" +
"15: 0xabcd1234\n" +
"15: 0xabcdef1234567890\n",
TextFormat.PrintToString(message));
}
/// <summary>
/// Helper to construct a ByteString from a string containing only 8-bit
/// characters. The characters are converted directly to bytes, *not*
/// encoded using UTF-8.
/// </summary>
private static ByteString Bytes(string str) {
return ByteString.CopyFrom(Encoding.GetEncoding(28591).GetBytes(str));
}
[Test]
public void PrintExotic() {
IMessage message = TestAllTypes.CreateBuilder()
// Signed vs. unsigned numbers.
.AddRepeatedInt32 (-1)
.AddRepeatedUint32(uint.MaxValue)
.AddRepeatedInt64 (-1)
.AddRepeatedUint64(ulong.MaxValue)
.AddRepeatedInt32 (1 << 31)
.AddRepeatedUint32(1U << 31)
.AddRepeatedInt64 (1L << 63)
.AddRepeatedUint64(1UL << 63)
// Floats of various precisions and exponents.
.AddRepeatedDouble(123)
.AddRepeatedDouble(123.5)
.AddRepeatedDouble(0.125)
.AddRepeatedDouble(123e15)
.AddRepeatedDouble(123.5e20)
.AddRepeatedDouble(123.5e-20)
.AddRepeatedDouble(123.456789)
.AddRepeatedDouble(Double.PositiveInfinity)
.AddRepeatedDouble(Double.NegativeInfinity)
.AddRepeatedDouble(Double.NaN)
// Strings and bytes that needing escaping.
.AddRepeatedString("\0\u0001\u0007\b\f\n\r\t\v\\\'\"\u1234")
.AddRepeatedBytes(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\"\u00fe"))
.Build();
Assert.AreEqual(ExoticText, message.ToString());
}
[Test]
public void PrintMessageSet() {
TestMessageSet messageSet =
TestMessageSet.CreateBuilder()
.SetExtension(
TestMessageSetExtension1.MessageSetExtension,
TestMessageSetExtension1.CreateBuilder().SetI(123).Build())
.SetExtension(
TestMessageSetExtension2.MessageSetExtension,
TestMessageSetExtension2.CreateBuilder().SetStr("foo").Build())
.Build();
Assert.AreEqual(MessageSetText, messageSet.ToString());
}
// =================================================================
[Test]
public void Parse() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge(AllFieldsSetText, builder);
TestUtil.AssertAllFieldsSet(builder.Build());
}
[Test]
public void ParseReader() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge(new StringReader(AllFieldsSetText), builder);
TestUtil.AssertAllFieldsSet(builder.Build());
}
[Test]
public void ParseExtensions() {
TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
TextFormat.Merge(AllExtensionsSetText,
TestUtil.CreateExtensionRegistry(),
builder);
TestUtil.AssertAllExtensionsSet(builder.Build());
}
[Test]
public void ParseCompatibility() {
string original = "repeated_float: inf\n" +
"repeated_float: -inf\n" +
"repeated_float: nan\n" +
"repeated_float: inff\n" +
"repeated_float: -inff\n" +
"repeated_float: nanf\n" +
"repeated_float: 1.0f\n" +
"repeated_float: infinityf\n" +
"repeated_float: -Infinityf\n" +
"repeated_double: infinity\n" +
"repeated_double: -infinity\n" +
"repeated_double: nan\n";
string canonical = "repeated_float: Infinity\n" +
"repeated_float: -Infinity\n" +
"repeated_float: NaN\n" +
"repeated_float: Infinity\n" +
"repeated_float: -Infinity\n" +
"repeated_float: NaN\n" +
"repeated_float: 1\n" + // Java has 1.0; this is fine
"repeated_float: Infinity\n" +
"repeated_float: -Infinity\n" +
"repeated_double: Infinity\n" +
"repeated_double: -Infinity\n" +
"repeated_double: NaN\n";
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge(original, builder);
Assert.AreEqual(canonical, builder.Build().ToString());
}
[Test]
public void ParseExotic() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge(ExoticText, builder);
// Too lazy to check things individually. Don't try to debug this
// if testPrintExotic() is Assert.Failing.
Assert.AreEqual(ExoticText, builder.Build().ToString());
}
[Test]
public void ParseMessageSet() {
ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
extensionRegistry.Add(TestMessageSetExtension1.MessageSetExtension);
extensionRegistry.Add(TestMessageSetExtension2.MessageSetExtension);
TestMessageSet.Builder builder = TestMessageSet.CreateBuilder();
TextFormat.Merge(MessageSetText, extensionRegistry, builder);
TestMessageSet messageSet = builder.Build();
Assert.IsTrue(messageSet.HasExtension(TestMessageSetExtension1.MessageSetExtension));
Assert.AreEqual(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I);
Assert.IsTrue(messageSet.HasExtension(TestMessageSetExtension2.MessageSetExtension));
Assert.AreEqual("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str);
}
[Test]
public void ParseNumericEnum() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge("optional_nested_enum: 2", builder);
Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, builder.OptionalNestedEnum);
}
[Test]
public void ParseAngleBrackets() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge("OptionalGroup: < a: 1 >", builder);
Assert.IsTrue(builder.HasOptionalGroup);
Assert.AreEqual(1, builder.OptionalGroup.A);
}
[Test]
public void ParseComment() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge(
"# this is a comment\n" +
"optional_int32: 1 # another comment\n" +
"optional_int64: 2\n" +
"# EOF comment", builder);
Assert.AreEqual(1, builder.OptionalInt32);
Assert.AreEqual(2, builder.OptionalInt64);
}
private static void AssertParseError(string error, string text) {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
try {
TextFormat.Merge(text, TestUtil.CreateExtensionRegistry(), builder);
Assert.Fail("Expected parse exception.");
} catch (FormatException e) {
Assert.AreEqual(error, e.Message);
}
}
[Test]
public void ParseErrors() {
AssertParseError(
"1:16: Expected \":\".",
"optional_int32 123");
AssertParseError(
"1:23: Expected identifier.",
"optional_nested_enum: ?");
AssertParseError(
"1:18: Couldn't parse integer: Number must be positive: -1",
"optional_uint32: -1");
AssertParseError(
"1:17: Couldn't parse integer: Number out of range for 32-bit signed " +
"integer: 82301481290849012385230157",
"optional_int32: 82301481290849012385230157");
AssertParseError(
"1:16: Expected \"true\" or \"false\".",
"optional_bool: maybe");
AssertParseError(
"1:18: Expected string.",
"optional_string: 123");
AssertParseError(
"1:18: String missing ending quote.",
"optional_string: \"ueoauaoe");
AssertParseError(
"1:18: String missing ending quote.",
"optional_string: \"ueoauaoe\n" +
"optional_int32: 123");
AssertParseError(
"1:18: Invalid escape sequence: '\\z'",
"optional_string: \"\\z\"");
AssertParseError(
"1:18: String missing ending quote.",
"optional_string: \"ueoauaoe\n" +
"optional_int32: 123");
AssertParseError(
"1:2: Extension \"nosuchext\" not found in the ExtensionRegistry.",
"[nosuchext]: 123");
AssertParseError(
"1:20: Extension \"protobuf_unittest.optional_int32_extension\" does " +
"not extend message type \"protobuf_unittest.TestAllTypes\".",
"[protobuf_unittest.optional_int32_extension]: 123");
AssertParseError(
"1:1: Message type \"protobuf_unittest.TestAllTypes\" has no field " +
"named \"nosuchfield\".",
"nosuchfield: 123");
AssertParseError(
"1:21: Expected \">\".",
"OptionalGroup < a: 1");
AssertParseError(
"1:23: Enum type \"protobuf_unittest.TestAllTypes.NestedEnum\" has no " +
"value named \"NO_SUCH_VALUE\".",
"optional_nested_enum: NO_SUCH_VALUE");
AssertParseError(
"1:23: Enum type \"protobuf_unittest.TestAllTypes.NestedEnum\" has no " +
"value with number 123.",
"optional_nested_enum: 123");
// Delimiters must match.
AssertParseError(
"1:22: Expected identifier.",
"OptionalGroup < a: 1 }");
AssertParseError(
"1:22: Expected identifier.",
"OptionalGroup { a: 1 >");
}
// =================================================================
private static ByteString Bytes(params byte[] bytes) {
return ByteString.CopyFrom(bytes);
}
private delegate void FormattingAction();
private static void AssertFormatException(FormattingAction action) {
try {
action();
Assert.Fail("Should have thrown an exception.");
} catch (FormatException) {
// success
}
}
[Test]
public void Escape() {
// Escape sequences.
Assert.AreEqual("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"",
TextFormat.EscapeBytes(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\"")));
Assert.AreEqual("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"",
TextFormat.EscapeText("\0\u0001\u0007\b\f\n\r\t\v\\\'\""));
Assert.AreEqual(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\""),
TextFormat.UnescapeBytes("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\""));
Assert.AreEqual("\0\u0001\u0007\b\f\n\r\t\v\\\'\"",
TextFormat.UnescapeText("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\""));
// Unicode handling.
Assert.AreEqual("\\341\\210\\264", TextFormat.EscapeText("\u1234"));
Assert.AreEqual("\\341\\210\\264", TextFormat.EscapeBytes(Bytes(0xe1, 0x88, 0xb4)));
Assert.AreEqual("\u1234", TextFormat.UnescapeText("\\341\\210\\264"));
Assert.AreEqual(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\341\\210\\264"));
Assert.AreEqual("\u1234", TextFormat.UnescapeText("\\xe1\\x88\\xb4"));
Assert.AreEqual(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\xe1\\x88\\xb4"));
// Errors.
AssertFormatException(() => TextFormat.UnescapeText("\\x"));
AssertFormatException(() => TextFormat.UnescapeText("\\z"));
AssertFormatException(() => TextFormat.UnescapeText("\\"));
}
[Test]
public void ParseInteger() {
Assert.AreEqual( 0, TextFormat.ParseInt32( "0"));
Assert.AreEqual( 1, TextFormat.ParseInt32( "1"));
Assert.AreEqual( -1, TextFormat.ParseInt32( "-1"));
Assert.AreEqual( 12345, TextFormat.ParseInt32( "12345"));
Assert.AreEqual( -12345, TextFormat.ParseInt32( "-12345"));
Assert.AreEqual( 2147483647, TextFormat.ParseInt32( "2147483647"));
Assert.AreEqual(-2147483648, TextFormat.ParseInt32("-2147483648"));
Assert.AreEqual( 0, TextFormat.ParseUInt32( "0"));
Assert.AreEqual( 1, TextFormat.ParseUInt32( "1"));
Assert.AreEqual( 12345, TextFormat.ParseUInt32( "12345"));
Assert.AreEqual( 2147483647, TextFormat.ParseUInt32("2147483647"));
Assert.AreEqual(2147483648U, TextFormat.ParseUInt32("2147483648"));
Assert.AreEqual(4294967295U, TextFormat.ParseUInt32("4294967295"));
Assert.AreEqual( 0L, TextFormat.ParseInt64( "0"));
Assert.AreEqual( 1L, TextFormat.ParseInt64( "1"));
Assert.AreEqual( -1L, TextFormat.ParseInt64( "-1"));
Assert.AreEqual( 12345L, TextFormat.ParseInt64( "12345"));
Assert.AreEqual( -12345L, TextFormat.ParseInt64( "-12345"));
Assert.AreEqual( 2147483647L, TextFormat.ParseInt64( "2147483647"));
Assert.AreEqual(-2147483648L, TextFormat.ParseInt64("-2147483648"));
Assert.AreEqual( 4294967295L, TextFormat.ParseInt64( "4294967295"));
Assert.AreEqual( 4294967296L, TextFormat.ParseInt64( "4294967296"));
Assert.AreEqual(9223372036854775807L, TextFormat.ParseInt64("9223372036854775807"));
Assert.AreEqual(-9223372036854775808L, TextFormat.ParseInt64("-9223372036854775808"));
Assert.AreEqual( 0L, TextFormat.ParseUInt64( "0"));
Assert.AreEqual( 1L, TextFormat.ParseUInt64( "1"));
Assert.AreEqual( 12345L, TextFormat.ParseUInt64( "12345"));
Assert.AreEqual( 2147483647L, TextFormat.ParseUInt64( "2147483647"));
Assert.AreEqual( 4294967295L, TextFormat.ParseUInt64( "4294967295"));
Assert.AreEqual( 4294967296L, TextFormat.ParseUInt64( "4294967296"));
Assert.AreEqual(9223372036854775807UL, TextFormat.ParseUInt64("9223372036854775807"));
Assert.AreEqual(9223372036854775808UL, TextFormat.ParseUInt64("9223372036854775808"));
Assert.AreEqual(18446744073709551615UL, TextFormat.ParseUInt64("18446744073709551615"));
// Hex
Assert.AreEqual(0x1234abcd, TextFormat.ParseInt32("0x1234abcd"));
Assert.AreEqual(-0x1234abcd, TextFormat.ParseInt32("-0x1234abcd"));
Assert.AreEqual(0xffffffffffffffffUL, TextFormat.ParseUInt64("0xffffffffffffffff"));
Assert.AreEqual(0x7fffffffffffffffL,
TextFormat.ParseInt64("0x7fffffffffffffff"));
// Octal
Assert.AreEqual(342391, TextFormat.ParseInt32("01234567"));
// Out-of-range
AssertFormatException(() => TextFormat.ParseInt32("2147483648"));
AssertFormatException(() => TextFormat.ParseInt32("-2147483649"));
AssertFormatException(() => TextFormat.ParseUInt32("4294967296"));
AssertFormatException(() => TextFormat.ParseUInt32("-1"));
AssertFormatException(() => TextFormat.ParseInt64("9223372036854775808"));
AssertFormatException(() => TextFormat.ParseInt64("-9223372036854775809"));
AssertFormatException(() => TextFormat.ParseUInt64("18446744073709551616"));
AssertFormatException(() => TextFormat.ParseUInt64("-1"));
AssertFormatException(() => TextFormat.ParseInt32("abcd"));
}
}
}

314
csharp/ProtocolBuffers.Test/UnknownFieldSetTest.cs
View file

@ -1,314 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections.Generic;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework;
namespace Google.ProtocolBuffers {
[TestFixture]
public class UnknownFieldSetTest {
private MessageDescriptor descriptor;
private TestAllTypes allFields;
private ByteString allFieldsData;
/// <summary>
/// An empty message that has been parsed from allFieldsData. So, it has
/// unknown fields of every type.
/// </summary>
private TestEmptyMessage emptyMessage;
private UnknownFieldSet unknownFields;
[SetUp]
public void SetUp() {
descriptor = TestAllTypes.Descriptor;
allFields = TestUtil.GetAllSet();
allFieldsData = allFields.ToByteString();
emptyMessage = TestEmptyMessage.ParseFrom(allFieldsData);
unknownFields = emptyMessage.UnknownFields;
}
private UnknownField GetField(String name) {
FieldDescriptor field = descriptor.FindDescriptor<FieldDescriptor>(name);
Assert.IsNotNull(field);
return unknownFields.FieldDictionary[field.FieldNumber];
}
/// <summary>
/// Constructs a protocol buffer which contains fields with all the same
/// numbers as allFieldsData except that each field is some other wire
/// type.
/// </summary>
private ByteString GetBizarroData() {
UnknownFieldSet.Builder bizarroFields = UnknownFieldSet.CreateBuilder();
UnknownField varintField = UnknownField.CreateBuilder().AddVarint(1).Build();
UnknownField fixed32Field = UnknownField.CreateBuilder().AddFixed32(1).Build();
foreach (KeyValuePair<int, UnknownField> entry in unknownFields.FieldDictionary) {
if (entry.Value.VarintList.Count == 0) {
// Original field is not a varint, so use a varint.
bizarroFields.AddField(entry.Key, varintField);
} else {
// Original field *is* a varint, so use something else.
bizarroFields.AddField(entry.Key, fixed32Field);
}
}
return bizarroFields.Build().ToByteString();
}
// =================================================================
[Test]
public void Varint() {
UnknownField field = GetField("optional_int32");
Assert.AreEqual(1, field.VarintList.Count);
Assert.AreEqual(allFields.OptionalInt32, (long) field.VarintList[0]);
}
[Test]
public void Fixed32() {
UnknownField field = GetField("optional_fixed32");
Assert.AreEqual(1, field.Fixed32List.Count);
Assert.AreEqual(allFields.OptionalFixed32, (int) field.Fixed32List[0]);
}
[Test]
public void Fixed64() {
UnknownField field = GetField("optional_fixed64");
Assert.AreEqual(1, field.Fixed64List.Count);
Assert.AreEqual(allFields.OptionalFixed64, (long) field.Fixed64List[0]);
}
[Test]
public void LengthDelimited() {
UnknownField field = GetField("optional_bytes");
Assert.AreEqual(1, field.LengthDelimitedList.Count);
Assert.AreEqual(allFields.OptionalBytes, field.LengthDelimitedList[0]);
}
[Test]
public void Group() {
FieldDescriptor nestedFieldDescriptor =
TestAllTypes.Types.OptionalGroup.Descriptor.FindDescriptor<FieldDescriptor>("a");
Assert.IsNotNull(nestedFieldDescriptor);
UnknownField field = GetField("optionalgroup");
Assert.AreEqual(1, field.GroupList.Count);
UnknownFieldSet group = field.GroupList[0];
Assert.AreEqual(1, group.FieldDictionary.Count);
Assert.IsTrue(group.HasField(nestedFieldDescriptor.FieldNumber));
UnknownField nestedField = group[nestedFieldDescriptor.FieldNumber];
Assert.AreEqual(1, nestedField.VarintList.Count);
Assert.AreEqual(allFields.OptionalGroup.A, (long) nestedField.VarintList[0]);
}
[Test]
public void Serialize() {
// Check that serializing the UnknownFieldSet produces the original data again.
ByteString data = emptyMessage.ToByteString();
Assert.AreEqual(allFieldsData, data);
}
[Test]
public void CopyFrom() {
TestEmptyMessage message =
TestEmptyMessage.CreateBuilder().MergeFrom(emptyMessage).Build();
Assert.AreEqual(emptyMessage.ToString(), message.ToString());
}
[Test]
public void MergeFrom() {
TestEmptyMessage source =
TestEmptyMessage.CreateBuilder()
.SetUnknownFields(
UnknownFieldSet.CreateBuilder()
.AddField(2,
UnknownField.CreateBuilder()
.AddVarint(2).Build())
.AddField(3,
UnknownField.CreateBuilder()
.AddVarint(4).Build())
.Build())
.Build();
TestEmptyMessage destination =
TestEmptyMessage.CreateBuilder()
.SetUnknownFields(
UnknownFieldSet.CreateBuilder()
.AddField(1,
UnknownField.CreateBuilder()
.AddVarint(1).Build())
.AddField(3,
UnknownField.CreateBuilder()
.AddVarint(3).Build())
.Build())
.MergeFrom(source)
.Build();
Assert.AreEqual(
"1: 1\n" +
"2: 2\n" +
"3: 3\n" +
"3: 4\n",
destination.ToString());
}
[Test]
public void Clear() {
UnknownFieldSet fields =
UnknownFieldSet.CreateBuilder().MergeFrom(unknownFields).Clear().Build();
Assert.AreEqual(0, fields.FieldDictionary.Count);
}
[Test]
public void ClearMessage() {
TestEmptyMessage message =
TestEmptyMessage.CreateBuilder().MergeFrom(emptyMessage).Clear().Build();
Assert.AreEqual(0, message.SerializedSize);
}
[Test]
public void ParseKnownAndUnknown() {
// Test mixing known and unknown fields when parsing.
UnknownFieldSet fields =
UnknownFieldSet.CreateBuilder(unknownFields)
.AddField(123456,
UnknownField.CreateBuilder().AddVarint(654321).Build())
.Build();
ByteString data = fields.ToByteString();
TestAllTypes destination = TestAllTypes.ParseFrom(data);
TestUtil.AssertAllFieldsSet(destination);
Assert.AreEqual(1, destination.UnknownFields.FieldDictionary.Count);
UnknownField field = destination.UnknownFields[123456];
Assert.AreEqual(1, field.VarintList.Count);
Assert.AreEqual(654321, (long) field.VarintList[0]);
}
[Test]
public void WrongTypeTreatedAsUnknown() {
// Test that fields of the wrong wire type are treated like unknown fields
// when parsing.
ByteString bizarroData = GetBizarroData();
TestAllTypes allTypesMessage = TestAllTypes.ParseFrom(bizarroData);
TestEmptyMessage emptyMessage = TestEmptyMessage.ParseFrom(bizarroData);
// All fields should have been interpreted as unknown, so the debug strings
// should be the same.
Assert.AreEqual(emptyMessage.ToString(), allTypesMessage.ToString());
}
[Test]
public void UnknownExtensions() {
// Make sure fields are properly parsed to the UnknownFieldSet even when
// they are declared as extension numbers.
TestEmptyMessageWithExtensions message =
TestEmptyMessageWithExtensions.ParseFrom(allFieldsData);
Assert.AreEqual(unknownFields.FieldDictionary.Count,
message.UnknownFields.FieldDictionary.Count);
Assert.AreEqual(allFieldsData, message.ToByteString());
}
[Test]
public void WrongExtensionTypeTreatedAsUnknown() {
// Test that fields of the wrong wire type are treated like unknown fields
// when parsing extensions.
ByteString bizarroData = GetBizarroData();
TestAllExtensions allExtensionsMessage = TestAllExtensions.ParseFrom(bizarroData);
TestEmptyMessage emptyMessage = TestEmptyMessage.ParseFrom(bizarroData);
// All fields should have been interpreted as unknown, so the debug strings
// should be the same.
Assert.AreEqual(emptyMessage.ToString(),
allExtensionsMessage.ToString());
}
[Test]
public void ParseUnknownEnumValue() {
FieldDescriptor singularField = TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("optional_nested_enum");
FieldDescriptor repeatedField = TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("repeated_nested_enum");
Assert.IsNotNull(singularField);
Assert.IsNotNull(repeatedField);
ByteString data =
UnknownFieldSet.CreateBuilder()
.AddField(singularField.FieldNumber,
UnknownField.CreateBuilder()
.AddVarint((int) TestAllTypes.Types.NestedEnum.BAR)
.AddVarint(5) // not valid
.Build())
.AddField(repeatedField.FieldNumber,
UnknownField.CreateBuilder()
.AddVarint((int) TestAllTypes.Types.NestedEnum.FOO)
.AddVarint(4) // not valid
.AddVarint((int) TestAllTypes.Types.NestedEnum.BAZ)
.AddVarint(6) // not valid
.Build())
.Build()
.ToByteString();
{
TestAllTypes message = TestAllTypes.ParseFrom(data);
Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR,
message.OptionalNestedEnum);
TestUtil.AssertEqual(new [] {TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.BAZ},
message.RepeatedNestedEnumList);
TestUtil.AssertEqual(new[] {5UL}, message.UnknownFields[singularField.FieldNumber].VarintList);
TestUtil.AssertEqual(new[] {4UL, 6UL}, message.UnknownFields[repeatedField.FieldNumber].VarintList);
}
{
TestAllExtensions message =
TestAllExtensions.ParseFrom(data, TestUtil.CreateExtensionRegistry());
Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR,
message.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension));
TestUtil.AssertEqual(new[] { TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.BAZ },
message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension));
TestUtil.AssertEqual(new[] { 5UL }, message.UnknownFields[singularField.FieldNumber].VarintList);
TestUtil.AssertEqual(new[] { 4UL, 6UL }, message.UnknownFields[repeatedField.FieldNumber].VarintList);
}
}
[Test]
public void LargeVarint() {
ByteString data =
UnknownFieldSet.CreateBuilder()
.AddField(1,
UnknownField.CreateBuilder()
.AddVarint(0x7FFFFFFFFFFFFFFFL)
.Build())
.Build()
.ToByteString();
UnknownFieldSet parsed = UnknownFieldSet.ParseFrom(data);
UnknownField field = parsed[1];
Assert.AreEqual(1, field.VarintList.Count);
Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, field.VarintList[0]);
}
}
}

228
csharp/ProtocolBuffers.Test/WireFormatTest.cs
View file

@ -1,228 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.Reflection;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.TestProtos;
using NUnit.Framework;
namespace Google.ProtocolBuffers {
[TestFixture]
public class WireFormatTest {
/// <summary>
/// Keeps the attributes on FieldType and the switch statement in WireFormat in sync.
/// </summary>
[Test]
public void FieldTypeToWireTypeMapping() {
foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public)) {
FieldType fieldType = (FieldType)field.GetValue(null);
FieldMappingAttribute mapping = (FieldMappingAttribute)field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0];
Assert.AreEqual(mapping.WireType, WireFormat.GetWireType(fieldType));
}
}
[Test]
public void Serialization() {
TestAllTypes message = TestUtil.GetAllSet();
ByteString rawBytes = message.ToByteString();
Assert.AreEqual(rawBytes.Length, message.SerializedSize);
TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes);
TestUtil.AssertAllFieldsSet(message2);
}
[Test]
public void SerializeExtensions() {
// TestAllTypes and TestAllExtensions should have compatible wire formats,
// so if we serealize a TestAllExtensions then parse it as TestAllTypes
// it should work.
TestAllExtensions message = TestUtil.GetAllExtensionsSet();
ByteString rawBytes = message.ToByteString();
Assert.AreEqual(rawBytes.Length, message.SerializedSize);
TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes);
TestUtil.AssertAllFieldsSet(message2);
}
[Test]
public void ParseExtensions() {
// TestAllTypes and TestAllExtensions should have compatible wire formats,
// so if we serealize a TestAllTypes then parse it as TestAllExtensions
// it should work.
TestAllTypes message = TestUtil.GetAllSet();
ByteString rawBytes = message.ToByteString();
ExtensionRegistry registry = ExtensionRegistry.CreateInstance();
TestUtil.RegisterAllExtensions(registry);
registry = registry.AsReadOnly();
TestAllExtensions message2 =
TestAllExtensions.ParseFrom(rawBytes, registry);
TestUtil.AssertAllExtensionsSet(message2);
}
[Test]
public void ExtensionsSerializedSize() {
Assert.AreEqual(TestUtil.GetAllSet().SerializedSize, TestUtil.GetAllExtensionsSet().SerializedSize);
}
private void AssertFieldsInOrder(ByteString data) {
CodedInputStream input = data.CreateCodedInput();
uint previousTag = 0;
while (true) {
uint tag = input.ReadTag();
if (tag == 0) {
break;
}
Assert.IsTrue(tag > previousTag);
previousTag = tag;
input.SkipField(tag);
}
}
[Test]
public void InterleavedFieldsAndExtensions() {
// Tests that fields are written in order even when extension ranges
// are interleaved with field numbers.
ByteString data =
TestFieldOrderings.CreateBuilder()
.SetMyInt(1)
.SetMyString("foo")
.SetMyFloat(1.0F)
.SetExtension(UnitTestProtoFile.MyExtensionInt, 23)
.SetExtension(UnitTestProtoFile.MyExtensionString, "bar")
.Build().ToByteString();
AssertFieldsInOrder(data);
MessageDescriptor descriptor = TestFieldOrderings.Descriptor;
ByteString dynamic_data =
DynamicMessage.CreateBuilder(TestFieldOrderings.Descriptor)
.SetField(descriptor.FindDescriptor<FieldDescriptor>("my_int"), 1L)
.SetField(descriptor.FindDescriptor<FieldDescriptor>("my_string"), "foo")
.SetField(descriptor.FindDescriptor<FieldDescriptor>("my_float"), 1.0F)
.SetField(UnitTestProtoFile.MyExtensionInt.Descriptor, 23)
.SetField(UnitTestProtoFile.MyExtensionString.Descriptor, "bar")
.WeakBuild().ToByteString();
AssertFieldsInOrder(dynamic_data);
}
private const int UnknownTypeId = 1550055;
private static readonly int TypeId1 = TestMessageSetExtension1.Descriptor.Extensions[0].FieldNumber;
private static readonly int TypeId2 = TestMessageSetExtension2.Descriptor.Extensions[0].FieldNumber;
[Test]
public void SerializeMessageSet() {
// Set up a TestMessageSet with two known messages and an unknown one.
TestMessageSet messageSet =
TestMessageSet.CreateBuilder()
.SetExtension(
TestMessageSetExtension1.MessageSetExtension,
TestMessageSetExtension1.CreateBuilder().SetI(123).Build())
.SetExtension(
TestMessageSetExtension2.MessageSetExtension,
TestMessageSetExtension2.CreateBuilder().SetStr("foo").Build())
.SetUnknownFields(
UnknownFieldSet.CreateBuilder()
.AddField(UnknownTypeId,
UnknownField.CreateBuilder()
.AddLengthDelimited(ByteString.CopyFromUtf8("bar"))
.Build())
.Build())
.Build();
ByteString data = messageSet.ToByteString();
// Parse back using RawMessageSet and check the contents.
RawMessageSet raw = RawMessageSet.ParseFrom(data);
Assert.AreEqual(0, raw.UnknownFields.FieldDictionary.Count);
Assert.AreEqual(3, raw.ItemCount);
Assert.AreEqual(TypeId1, raw.ItemList[0].TypeId);
Assert.AreEqual(TypeId2, raw.ItemList[1].TypeId);
Assert.AreEqual(UnknownTypeId, raw.ItemList[2].TypeId);
TestMessageSetExtension1 message1 = TestMessageSetExtension1.ParseFrom(raw.GetItem(0).Message.ToByteArray());
Assert.AreEqual(123, message1.I);
TestMessageSetExtension2 message2 = TestMessageSetExtension2.ParseFrom(raw.GetItem(1).Message.ToByteArray());
Assert.AreEqual("foo", message2.Str);
Assert.AreEqual("bar", raw.GetItem(2).Message.ToStringUtf8());
}
[Test]
public void ParseMessageSet() {
ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
extensionRegistry.Add(TestMessageSetExtension1.MessageSetExtension);
extensionRegistry.Add(TestMessageSetExtension2.MessageSetExtension);
// Set up a RawMessageSet with two known messages and an unknown one.
RawMessageSet raw =
RawMessageSet.CreateBuilder()
.AddItem(
RawMessageSet.Types.Item.CreateBuilder()
.SetTypeId(TypeId1)
.SetMessage(
TestMessageSetExtension1.CreateBuilder()
.SetI(123)
.Build().ToByteString())
.Build())
.AddItem(
RawMessageSet.Types.Item.CreateBuilder()
.SetTypeId(TypeId2)
.SetMessage(
TestMessageSetExtension2.CreateBuilder()
.SetStr("foo")
.Build().ToByteString())
.Build())
.AddItem(
RawMessageSet.Types.Item.CreateBuilder()
.SetTypeId(UnknownTypeId)
.SetMessage(ByteString.CopyFromUtf8("bar"))
.Build())
.Build();
ByteString data = raw.ToByteString();
// Parse as a TestMessageSet and check the contents.
TestMessageSet messageSet =
TestMessageSet.ParseFrom(data, extensionRegistry);
Assert.AreEqual(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I);
Assert.AreEqual("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str);
// Check for unknown field with type LENGTH_DELIMITED,
// number UNKNOWN_TYPE_ID, and contents "bar".
UnknownFieldSet unknownFields = messageSet.UnknownFields;
Assert.AreEqual(1, unknownFields.FieldDictionary.Count);
Assert.IsTrue(unknownFields.HasField(UnknownTypeId));
UnknownField field = unknownFields[UnknownTypeId];
Assert.AreEqual(1, field.LengthDelimitedList.Count);
Assert.AreEqual("bar", field.LengthDelimitedList[0].ToStringUtf8());
}
}
}

222
csharp/ProtocolBuffers/AbstractBuilder.cs
View file

@ -1,222 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers {
/// <summary>
/// Implementation of the non-generic IMessage interface as far as possible.
/// </summary>
public abstract class AbstractBuilder<TMessage, TBuilder> : IBuilder<TMessage, TBuilder>
where TMessage : AbstractMessage<TMessage, TBuilder>
where TBuilder : AbstractBuilder<TMessage, TBuilder> {
protected abstract TBuilder ThisBuilder { get; }
#region Unimplemented members of IBuilder
public abstract UnknownFieldSet UnknownFields { get; set; }
public abstract TBuilder MergeFrom(TMessage other);
public abstract bool IsInitialized { get; }
public abstract IDictionary<FieldDescriptor, object> AllFields { get; }
public abstract object this[FieldDescriptor field] { get; set; }
public abstract MessageDescriptor DescriptorForType { get; }
public abstract int GetRepeatedFieldCount(FieldDescriptor field);
public abstract object this[FieldDescriptor field, int index] { get; set; }
public abstract bool HasField(FieldDescriptor field);
public abstract TMessage Build();
public abstract TMessage BuildPartial();
public abstract TBuilder Clone();
public abstract TMessage DefaultInstanceForType { get; }
public abstract IBuilder CreateBuilderForField(FieldDescriptor field);
public abstract TBuilder ClearField(FieldDescriptor field);
public abstract TBuilder AddRepeatedField(FieldDescriptor field, object value);
#endregion
#region Implementation of methods which don't require type parameter information
public IMessage WeakBuild() {
return Build();
}
public IBuilder WeakAddRepeatedField(FieldDescriptor field, object value) {
return AddRepeatedField(field, value);
}
public IBuilder WeakClear() {
return Clear();
}
public IBuilder WeakMergeFrom(IMessage message) {
return MergeFrom(message);
}
public IBuilder WeakMergeFrom(CodedInputStream input) {
return MergeFrom(input);
}
public IBuilder WeakMergeFrom(CodedInputStream input, ExtensionRegistry registry) {
return MergeFrom(input, registry);
}
public IBuilder WeakMergeFrom(ByteString data) {
return MergeFrom(data);
}
public IBuilder WeakMergeFrom(ByteString data, ExtensionRegistry registry) {
return MergeFrom(data, registry);
}
public IMessage WeakBuildPartial() {
return BuildPartial();
}
public IBuilder WeakClone() {
return Clone();
}
public IMessage WeakDefaultInstanceForType {
get { return DefaultInstanceForType; }
}
public IBuilder WeakClearField(FieldDescriptor field) {
return ClearField(field);
}
#endregion
public TBuilder SetUnknownFields(UnknownFieldSet fields) {
UnknownFields = fields;
return ThisBuilder;
}
public virtual TBuilder Clear() {
foreach(FieldDescriptor field in AllFields.Keys) {
ClearField(field);
}
return ThisBuilder;
}
public virtual TBuilder MergeFrom(IMessage other) {
if (other.DescriptorForType != DescriptorForType) {
throw new ArgumentException("MergeFrom(IMessage) can only merge messages of the same type.");
}
// Note: We don't attempt to verify that other's fields have valid
// types. Doing so would be a losing battle. We'd have to verify
// all sub-messages as well, and we'd have to make copies of all of
// them to insure that they don't change after verification (since
// the Message interface itself cannot enforce immutability of
// implementations).
// TODO(jonskeet): Provide a function somewhere called MakeDeepCopy()
// which allows people to make secure deep copies of messages.
foreach (KeyValuePair<FieldDescriptor, object> entry in other.AllFields) {
FieldDescriptor field = entry.Key;
if (field.IsRepeated) {
// Concatenate repeated fields
foreach (object element in (IEnumerable) entry.Value) {
AddRepeatedField(field, element);
}
} else if (field.MappedType == MappedType.Message) {
// Merge singular messages
IMessage existingValue = (IMessage) this[field];
if (existingValue == existingValue.WeakDefaultInstanceForType) {
this[field] = entry.Value;
} else {
this[field] = existingValue.WeakCreateBuilderForType()
.WeakMergeFrom(existingValue)
.WeakMergeFrom((IMessage) entry.Value)
.WeakBuild();
}
} else {
// Overwrite simple values
this[field] = entry.Value;
}
}
return ThisBuilder;
}
public virtual TBuilder MergeFrom(CodedInputStream input) {
return MergeFrom(input, ExtensionRegistry.Empty);
}
public virtual TBuilder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry) {
UnknownFieldSet.Builder unknownFields = UnknownFieldSet.CreateBuilder(UnknownFields);
unknownFields.MergeFrom(input, extensionRegistry, this);
UnknownFields = unknownFields.Build();
return ThisBuilder;
}
public virtual TBuilder MergeUnknownFields(UnknownFieldSet unknownFields) {
UnknownFields = UnknownFieldSet.CreateBuilder(UnknownFields)
.MergeFrom(unknownFields)
.Build();
return ThisBuilder;
}
public virtual TBuilder MergeFrom(ByteString data) {
CodedInputStream input = data.CreateCodedInput();
MergeFrom(input);
input.CheckLastTagWas(0);
return ThisBuilder;
}
public virtual TBuilder MergeFrom(ByteString data, ExtensionRegistry extensionRegistry) {
CodedInputStream input = data.CreateCodedInput();
MergeFrom(input, extensionRegistry);
input.CheckLastTagWas(0);
return ThisBuilder;
}
public virtual TBuilder MergeFrom(byte[] data) {
CodedInputStream input = CodedInputStream.CreateInstance(data);
MergeFrom(input);
input.CheckLastTagWas(0);
return ThisBuilder;
}
public virtual TBuilder MergeFrom(byte[] data, ExtensionRegistry extensionRegistry) {
CodedInputStream input = CodedInputStream.CreateInstance(data);
MergeFrom(input, extensionRegistry);
input.CheckLastTagWas(0);
return ThisBuilder;
}
public virtual TBuilder MergeFrom(Stream input) {
CodedInputStream codedInput = CodedInputStream.CreateInstance(input);
MergeFrom(codedInput);
codedInput.CheckLastTagWas(0);
return ThisBuilder;
}
public virtual TBuilder MergeFrom(Stream input, ExtensionRegistry extensionRegistry) {
CodedInputStream codedInput = CodedInputStream.CreateInstance(input);
MergeFrom(codedInput, extensionRegistry);
codedInput.CheckLastTagWas(0);
return ThisBuilder;
}
public virtual IBuilder SetField(FieldDescriptor field, object value) {
this[field] = value;
return ThisBuilder;
}
public virtual IBuilder SetRepeatedField(FieldDescriptor field, int index, object value) {
this[field, index] = value;
return ThisBuilder;
}
}
}

181
csharp/ProtocolBuffers/AbstractMessage.cs
View file

@ -1,181 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.Collections;
using System.Collections.Generic;
using System.IO;
using Google.ProtocolBuffers.Collections;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers {
/// <summary>
/// Implementation of the non-generic IMessage interface as far as possible.
/// </summary>
public abstract class AbstractMessage<TMessage, TBuilder> : IMessage<TMessage, TBuilder>
where TMessage : AbstractMessage<TMessage, TBuilder>
where TBuilder : AbstractBuilder<TMessage, TBuilder> {
/// <summary>
/// The serialized size if it's already been computed, or null
/// if we haven't computed it yet.
/// </summary>
private int? memoizedSize = null;
#region Unimplemented members of IMessage
public abstract MessageDescriptor DescriptorForType { get; }
public abstract IDictionary<FieldDescriptor, object> AllFields { get; }
public abstract bool HasField(FieldDescriptor field);
public abstract object this[FieldDescriptor field] { get; }
public abstract int GetRepeatedFieldCount(FieldDescriptor field);
public abstract object this[FieldDescriptor field, int index] { get; }
public abstract UnknownFieldSet UnknownFields { get; }
public abstract TMessage DefaultInstanceForType { get; }
public abstract TBuilder CreateBuilderForType();
#endregion
public IBuilder WeakCreateBuilderForType() {
return CreateBuilderForType();
}
public IMessage WeakDefaultInstanceForType {
get { return DefaultInstanceForType; }
}
public virtual bool IsInitialized {
get {
// Check that all required fields are present.
foreach (FieldDescriptor field in DescriptorForType.Fields) {
if (field.IsRequired && !HasField(field)) {
return false;
}
}
// Check that embedded messages are initialized.
foreach (KeyValuePair<FieldDescriptor, object> entry in AllFields) {
FieldDescriptor field = entry.Key;
if (field.MappedType == MappedType.Message) {
if (field.IsRepeated) {
// We know it's an IList<T>, but not the exact type - so
// IEnumerable is the best we can do. (C# generics aren't covariant yet.)
foreach (IMessage element in (IEnumerable) entry.Value) {
if (!element.IsInitialized) {
return false;
}
}
} else {
if (!((IMessage)entry.Value).IsInitialized) {
return false;
}
}
}
}
return true;
}
}
public sealed override string ToString() {
return TextFormat.PrintToString(this);
}
public virtual void WriteTo(CodedOutputStream output) {
foreach (KeyValuePair<FieldDescriptor, object> entry in AllFields) {
FieldDescriptor field = entry.Key;
if (field.IsRepeated) {
// We know it's an IList<T>, but not the exact type - so
// IEnumerable is the best we can do. (C# generics aren't covariant yet.)
foreach (object element in (IEnumerable)entry.Value) {
output.WriteField(field.FieldType, field.FieldNumber, element);
}
} else {
output.WriteField(field.FieldType, field.FieldNumber, entry.Value);
}
}
UnknownFieldSet unknownFields = UnknownFields;
if (DescriptorForType.Options.MessageSetWireFormat) {
unknownFields.WriteAsMessageSetTo(output);
} else {
unknownFields.WriteTo(output);
}
}
public virtual int SerializedSize {
get {
if (memoizedSize != null) {
return memoizedSize.Value;
}
int size = 0;
foreach (KeyValuePair<FieldDescriptor, object> entry in AllFields) {
FieldDescriptor field = entry.Key;
if (field.IsRepeated) {
foreach (object element in (IEnumerable) entry.Value) {
size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, element);
}
} else {
size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, entry.Value);
}
}
UnknownFieldSet unknownFields = UnknownFields;
if (DescriptorForType.Options.MessageSetWireFormat) {
size += unknownFields.SerializedSizeAsMessageSet;
} else {
size += unknownFields.SerializedSize;
}
memoizedSize = size;
return size;
}
}
public ByteString ToByteString() {
ByteString.CodedBuilder output = new ByteString.CodedBuilder(SerializedSize);
WriteTo(output.CodedOutput);
return output.Build();
}
public byte[] ToByteArray() {
byte[] result = new byte[SerializedSize];
CodedOutputStream output = CodedOutputStream.CreateInstance(result);
WriteTo(output);
output.CheckNoSpaceLeft();
return result;
}
public void WriteTo(Stream output) {
CodedOutputStream codedOutput = CodedOutputStream.CreateInstance(output);
WriteTo(codedOutput);
codedOutput.Flush();
}
public override bool Equals(object other) {
if (other == this) {
return true;
}
IMessage otherMessage = other as IMessage;
if (otherMessage == null || otherMessage.DescriptorForType != DescriptorForType) {
return false;
}
return Dictionaries.Equals(AllFields, otherMessage.AllFields);
}
public override int GetHashCode() {
int hash = 41;
hash = (19 * hash) + DescriptorForType.GetHashCode();
hash = (53 * hash) + Dictionaries.GetHashCode(AllFields);
return hash;
}
}
}

187
csharp/ProtocolBuffers/ByteString.cs
View file

@ -1,187 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.Text;
namespace Google.ProtocolBuffers {
/// <summary>
/// Immutable array of bytes.
/// TODO(jonskeet): Implement the common collection interfaces?
/// </summary>
public sealed class ByteString : IEnumerable<byte>, IEquatable<ByteString> {
private static readonly ByteString empty = new ByteString(new byte[0]);
private readonly byte[] bytes;
/// <summary>
/// Constructs a new ByteString from the given byte array. The array is
/// *not* copied, and must not be modified after this constructor is called.
/// </summary>
private ByteString(byte[] bytes) {
this.bytes = bytes;
}
/// <summary>
/// Returns an empty ByteString.
/// </summary>
public static ByteString Empty {
get { return empty; }
}
/// <summary>
/// Returns the length of this ByteString in bytes.
/// </summary>
public int Length {
get { return bytes.Length; }
}
public bool IsEmpty {
get { return Length == 0; }
}
public byte[] ToByteArray() {
return (byte[])bytes.Clone();
}
/// <summary>
/// Constructs a ByteString from the given array. The contents
/// are copied, so further modifications to the array will not
/// be reflected in the returned ByteString.
/// </summary>
public static ByteString CopyFrom(byte[] bytes) {
return new ByteString((byte[]) bytes.Clone());
}
/// <summary>
/// Constructs a ByteString from a portion of a byte array.
/// </summary>
public static ByteString CopyFrom(byte[] bytes, int offset, int count) {
byte[] portion = new byte[count];
Array.Copy(bytes, offset, portion, 0, count);
return new ByteString(portion);
}
/// <summary>
/// Creates a new ByteString by encoding the specified text with
/// the given encoding.
/// </summary>
public static ByteString CopyFrom(string text, Encoding encoding) {
return new ByteString(encoding.GetBytes(text));
}
/// <summary>
/// Creates a new ByteString by encoding the specified text in UTF-8.
/// </summary>
public static ByteString CopyFromUtf8(string text) {
return CopyFrom(text, Encoding.UTF8);
}
/// <summary>
/// Retuns the byte at the given index.
/// </summary>
public byte this[int index] {
get { return bytes[index]; }
}
public string ToString(Encoding encoding) {
return encoding.GetString(bytes);
}
public string ToStringUtf8() {
return ToString(Encoding.UTF8);
}
public IEnumerator<byte> GetEnumerator() {
return ((IEnumerable<byte>) bytes).GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}
/// <summary>
/// Creates a CodedInputStream from this ByteString's data.
/// </summary>
public CodedInputStream CreateCodedInput() {
// We trust CodedInputStream not to reveal the provided byte array or modify it
return CodedInputStream.CreateInstance(bytes);
}
// TODO(jonskeet): CopyTo if it turns out to be required
public override bool Equals(object obj) {
ByteString other = obj as ByteString;
if (obj == null) {
return false;
}
return Equals(other);
}
public override int GetHashCode() {
int ret = 23;
foreach (byte b in bytes) {
ret = (ret << 8) | b;
}
return ret;
}
public bool Equals(ByteString other) {
if (other.bytes.Length != bytes.Length) {
return false;
}
for (int i = 0; i < bytes.Length; i++) {
if (other.bytes[i] != bytes[i]) {
return false;
}
}
return true;
}
/// <summary>
/// Builder for ByteStrings which allows them to be created without extra
/// copying being involved. This has to be a nested type in order to have access
/// to the private ByteString constructor.
/// </summary>
internal sealed class CodedBuilder {
private readonly CodedOutputStream output;
private readonly byte[] buffer;
internal CodedBuilder(int size) {
buffer = new byte[size];
output = CodedOutputStream.CreateInstance(buffer);
}
public ByteString Build() {
output.CheckNoSpaceLeft();
// We can be confident that the CodedOutputStream will not modify the
// underlying bytes anymore because it already wrote all of them. So,
// no need to make a copy.
return new ByteString(buffer);
}
public CodedOutputStream CodedOutput {
get {
return output;
}
}
}
}
}

843
csharp/ProtocolBuffers/CodedInputStream.cs
View file

@ -1,843 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers {
/// <summary>
/// Readings and decodes protocol message fields.
/// </summary>
/// <remarks>
/// This class contains two kinds of methods: methods that read specific
/// protocol message constructs and field types (e.g. ReadTag and
/// ReadInt32) and methods that read low-level values (e.g.
/// ReadRawVarint32 and ReadRawBytes). If you are reading encoded protocol
/// messages, you should use the former methods, but if you are reading some
/// other format of your own design, use the latter. The names of the former
/// methods are taken from the protocol buffer type names, not .NET types.
/// (Hence ReadFloat instead of ReadSingle, and ReadBool instead of ReadBoolean.)
///
/// TODO(jonskeet): Consider whether recursion and size limits shouldn't be readonly,
/// set at construction time.
/// </remarks>
public sealed class CodedInputStream {
private readonly byte[] buffer;
private int bufferSize;
private int bufferSizeAfterLimit = 0;
private int bufferPos = 0;
private readonly Stream input;
private uint lastTag = 0;
const int DefaultRecursionLimit = 64;
const int DefaultSizeLimit = 64 << 20; // 64MB
const int BufferSize = 4096;
/// <summary>
/// The total number of bytes read before the current buffer. The
/// total bytes read up to the current position can be computed as
/// totalBytesRetired + bufferPos.
/// </summary>
private int totalBytesRetired = 0;
/// <summary>
/// The absolute position of the end of the current message.
/// </summary>
private int currentLimit = int.MaxValue;
/// <summary>
/// <see cref="SetRecursionLimit"/>
/// </summary>
private int recursionDepth = 0;
private int recursionLimit = DefaultRecursionLimit;
/// <summary>
/// <see cref="SetSizeLimit"/>
/// </summary>
private int sizeLimit = DefaultSizeLimit;
#region Construction
/// <summary>
/// Creates a new CodedInputStream reading data from the given
/// stream.
/// </summary>
public static CodedInputStream CreateInstance(Stream input) {
return new CodedInputStream(input);
}
/// <summary>
/// Creates a new CodedInputStream reading data from the given
/// byte array.
/// </summary>
public static CodedInputStream CreateInstance(byte[] buf) {
return new CodedInputStream(buf);
}
private CodedInputStream(byte[] buffer) {
this.buffer = buffer;
this.bufferSize = buffer.Length;
this.input = null;
}
private CodedInputStream(Stream input) {
this.buffer = new byte[BufferSize];
this.bufferSize = 0;
this.input = input;
}
#endregion
#region Validation
/// <summary>
/// Verifies that the last call to ReadTag() returned the given tag value.
/// This is used to verify that a nested group ended with the correct
/// end tag.
/// </summary>
/// <exception cref="InvalidProtocolBufferException">The last
/// tag read was not the one specified</exception>
public void CheckLastTagWas(uint value) {
if (lastTag != value) {
throw InvalidProtocolBufferException.InvalidEndTag();
}
}
#endregion
#region Reading of tags etc
/// <summary>
/// Attempt to read a field tag, returning 0 if we have reached the end
/// of the input data. Protocol message parsers use this to read tags,
/// since a protocol message may legally end wherever a tag occurs, and
/// zero is not a valid tag number.
/// </summary>
public uint ReadTag() {
if (bufferPos == bufferSize && !RefillBuffer(false)) {
lastTag = 0;
return 0;
}
lastTag = ReadRawVarint32();
if (lastTag == 0) {
// If we actually read zero, that's not a valid tag.
throw InvalidProtocolBufferException.InvalidTag();
}
return lastTag;
}
/// <summary>
/// Read a double field from the stream.
/// </summary>
public double ReadDouble() {
// TODO(jonskeet): Test this on different endiannesses
return BitConverter.Int64BitsToDouble((long) ReadRawLittleEndian64());
}
/// <summary>
/// Read a float field from the stream.
/// </summary>
public float ReadFloat() {
// TODO(jonskeet): Test this on different endiannesses
uint raw = ReadRawLittleEndian32();
byte[] rawBytes = BitConverter.GetBytes(raw);
return BitConverter.ToSingle(rawBytes, 0);
}
/// <summary>
/// Read a uint64 field from the stream.
/// </summary>
public ulong ReadUInt64() {
return ReadRawVarint64();
}
/// <summary>
/// Read an int64 field from the stream.
/// </summary>
public long ReadInt64() {
return (long) ReadRawVarint64();
}
/// <summary>
/// Read an int32 field from the stream.
/// </summary>
public int ReadInt32() {
return (int) ReadRawVarint32();
}
/// <summary>
/// Read a fixed64 field from the stream.
/// </summary>
public ulong ReadFixed64() {
return ReadRawLittleEndian64();
}
/// <summary>
/// Read a fixed32 field from the stream.
/// </summary>
public uint ReadFixed32() {
return ReadRawLittleEndian32();
}
/// <summary>
/// Read a bool field from the stream.
/// </summary>
public bool ReadBool() {
return ReadRawVarint32() != 0;
}
/// <summary>
/// Reads a string field from the stream.
/// </summary>
public String ReadString() {
int size = (int) ReadRawVarint32();
if (size < bufferSize - bufferPos && size > 0) {
// Fast path: We already have the bytes in a contiguous buffer, so
// just copy directly from it.
String result = Encoding.UTF8.GetString(buffer, bufferPos, size);
bufferPos += size;
return result;
} else {
// Slow path: Build a byte array first then copy it.
return Encoding.UTF8.GetString(ReadRawBytes(size));
}
}
/// <summary>
/// Reads a group field value from the stream.
/// </summary>
public void ReadGroup(int fieldNumber, IBuilder builder,
ExtensionRegistry extensionRegistry) {
if (recursionDepth >= recursionLimit) {
throw InvalidProtocolBufferException.RecursionLimitExceeded();
}
++recursionDepth;
builder.WeakMergeFrom(this, extensionRegistry);
CheckLastTagWas(WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup));
--recursionDepth;
}
/// <summary>
/// Reads a group field value from the stream and merges it into the given
/// UnknownFieldSet.
/// </summary>
public void ReadUnknownGroup(int fieldNumber, UnknownFieldSet.Builder builder) {
if (recursionDepth >= recursionLimit) {
throw InvalidProtocolBufferException.RecursionLimitExceeded();
}
++recursionDepth;
builder.MergeFrom(this);
CheckLastTagWas(WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup));
--recursionDepth;
}
/// <summary>
/// Reads an embedded message field value from the stream.
/// </summary>
public void ReadMessage(IBuilder builder, ExtensionRegistry extensionRegistry) {
int length = (int) ReadRawVarint32();
if (recursionDepth >= recursionLimit) {
throw InvalidProtocolBufferException.RecursionLimitExceeded();
}
int oldLimit = PushLimit(length);
++recursionDepth;
builder.WeakMergeFrom(this, extensionRegistry);
CheckLastTagWas(0);
--recursionDepth;
PopLimit(oldLimit);
}
/// <summary>
/// Reads a bytes field value from the stream.
/// </summary>
public ByteString ReadBytes() {
int size = (int) ReadRawVarint32();
if (size < bufferSize - bufferPos && size > 0) {
// Fast path: We already have the bytes in a contiguous buffer, so
// just copy directly from it.
ByteString result = ByteString.CopyFrom(buffer, bufferPos, size);
bufferPos += size;
return result;
} else {
// Slow path: Build a byte array first then copy it.
return ByteString.CopyFrom(ReadRawBytes(size));
}
}
/// <summary>
/// Reads a uint32 field value from the stream.
/// </summary>
public uint ReadUInt32() {
return ReadRawVarint32();
}
/// <summary>
/// Reads an enum field value from the stream. The caller is responsible
/// for converting the numeric value to an actual enum.
/// </summary>
public int ReadEnum() {
return (int) ReadRawVarint32();
}
/// <summary>
/// Reads an sfixed32 field value from the stream.
/// </summary>
public int ReadSFixed32() {
return (int) ReadRawLittleEndian32();
}
/// <summary>
/// Reads an sfixed64 field value from the stream.
/// </summary>
public long ReadSFixed64() {
return (long) ReadRawLittleEndian64();
}
/// <summary>
/// Reads an sint32 field value from the stream.
/// </summary>
public int ReadSInt32() {
return DecodeZigZag32(ReadRawVarint32());
}
/// <summary>
/// Reads an sint64 field value from the stream.
/// </summary>
public long ReadSInt64() {
return DecodeZigZag64(ReadRawVarint64());
}
/// <summary>
/// Reads a field of any primitive type. Enums, groups and embedded
/// messages are not handled by this method.
/// </summary>
public object ReadPrimitiveField(FieldType fieldType) {
switch (fieldType) {
case FieldType.Double: return ReadDouble();
case FieldType.Float: return ReadFloat();
case FieldType.Int64: return ReadInt64();
case FieldType.UInt64: return ReadUInt64();
case FieldType.Int32: return ReadInt32();
case FieldType.Fixed64: return ReadFixed64();
case FieldType.Fixed32: return ReadFixed32();
case FieldType.Bool: return ReadBool();
case FieldType.String: return ReadString();
case FieldType.Bytes: return ReadBytes();
case FieldType.UInt32: return ReadUInt32();
case FieldType.SFixed32: return ReadSFixed32();
case FieldType.SFixed64: return ReadSFixed64();
case FieldType.SInt32: return ReadSInt32();
case FieldType.SInt64: return ReadSInt64();
case FieldType.Group:
throw new ArgumentException("ReadPrimitiveField() cannot handle nested groups.");
case FieldType.Message:
throw new ArgumentException("ReadPrimitiveField() cannot handle embedded messages.");
// We don't handle enums because we don't know what to do if the
// value is not recognized.
case FieldType.Enum:
throw new ArgumentException("ReadPrimitiveField() cannot handle enums.");
default:
throw new ArgumentOutOfRangeException("Invalid field type " + fieldType);
}
}
#endregion
#region Underlying reading primitives
/// <summary>
/// Same code as ReadRawVarint32, but read each byte individually, checking for
/// buffer overflow.
/// </summary>
private uint SlowReadRawVarint32() {
int tmp = ReadRawByte();
if (tmp < 128) {
return (uint)tmp;
}
int result = tmp & 0x7f;
if ((tmp = ReadRawByte()) < 128) {
result |= tmp << 7;
} else {
result |= (tmp & 0x7f) << 7;
if ((tmp = ReadRawByte()) < 128) {
result |= tmp << 14;
} else {
result |= (tmp & 0x7f) << 14;
if ((tmp = ReadRawByte()) < 128) {
result |= tmp << 21;
} else {
result |= (tmp & 0x7f) << 21;
result |= (tmp = ReadRawByte()) << 28;
if (tmp >= 128) {
// Discard upper 32 bits.
for (int i = 0; i < 5; i++) {
if (ReadRawByte() < 128) return (uint)result;
}
throw InvalidProtocolBufferException.MalformedVarint();
}
}
}
}
return (uint)result;
}
/// <summary>
/// Read a raw Varint from the stream. If larger than 32 bits, discard the upper bits.
/// This method is optimised for the case where we've got lots of data in the buffer.
/// That means we can check the size just once, then just read directly from the buffer
/// without constant rechecking of the buffer length.
/// </summary>
public uint ReadRawVarint32() {
if (bufferPos + 5 > bufferSize) {
return SlowReadRawVarint32();
}
int tmp = buffer[bufferPos++];
if (tmp < 128) {
return (uint)tmp;
}
int result = tmp & 0x7f;
if ((tmp = buffer[bufferPos++]) < 128) {
result |= tmp << 7;
} else {
result |= (tmp & 0x7f) << 7;
if ((tmp = buffer[bufferPos++]) < 128) {
result |= tmp << 14;
} else {
result |= (tmp & 0x7f) << 14;
if ((tmp = buffer[bufferPos++]) < 128) {
result |= tmp << 21;
} else {
result |= (tmp & 0x7f) << 21;
result |= (tmp = buffer[bufferPos++]) << 28;
if (tmp >= 128) {
// Discard upper 32 bits.
// Note that this has to use ReadRawByte() as we only ensure we've
// got at least 5 bytes at the start of the method. This lets us
// use the fast path in more cases, and we rarely hit this section of code.
for (int i = 0; i < 5; i++) {
if (ReadRawByte() < 128) return (uint)result;
}
throw InvalidProtocolBufferException.MalformedVarint();
}
}
}
}
return (uint)result;
}
/// <summary>
/// Read a raw varint from the stream.
/// </summary>
public ulong ReadRawVarint64() {
int shift = 0;
ulong result = 0;
while (shift < 64) {
byte b = ReadRawByte();
result |= (ulong)(b & 0x7F) << shift;
if ((b & 0x80) == 0) {
return result;
}
shift += 7;
}
throw InvalidProtocolBufferException.MalformedVarint();
}
/// <summary>
/// Read a 32-bit little-endian integer from the stream.
/// </summary>
public uint ReadRawLittleEndian32() {
uint b1 = ReadRawByte();
uint b2 = ReadRawByte();
uint b3 = ReadRawByte();
uint b4 = ReadRawByte();
return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
}
/// <summary>
/// Read a 64-bit little-endian integer from the stream.
/// </summary>
public ulong ReadRawLittleEndian64() {
ulong b1 = ReadRawByte();
ulong b2 = ReadRawByte();
ulong b3 = ReadRawByte();
ulong b4 = ReadRawByte();
ulong b5 = ReadRawByte();
ulong b6 = ReadRawByte();
ulong b7 = ReadRawByte();
ulong b8 = ReadRawByte();
return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24)
| (b5 << 32) | (b6 << 40) | (b7 << 48) | (b8 << 56);
}
#endregion
/// <summary>
/// Decode a 32-bit value with ZigZag encoding.
/// </summary>
/// <remarks>
/// ZigZag encodes signed integers into values that can be efficiently
/// encoded with varint. (Otherwise, negative values must be
/// sign-extended to 64 bits to be varint encoded, thus always taking
/// 10 bytes on the wire.)
/// </remarks>
public static int DecodeZigZag32(uint n) {
return (int)(n >> 1) ^ -(int)(n & 1);
}
/// <summary>
/// Decode a 32-bit value with ZigZag encoding.
/// </summary>
/// <remarks>
/// ZigZag encodes signed integers into values that can be efficiently
/// encoded with varint. (Otherwise, negative values must be
/// sign-extended to 64 bits to be varint encoded, thus always taking
/// 10 bytes on the wire.)
/// </remarks>
public static long DecodeZigZag64(ulong n) {
return (long)(n >> 1) ^ -(long)(n & 1);
}
/// <summary>
/// Set the maximum message recursion depth.
/// </summary>
/// <remarks>
/// In order to prevent malicious
/// messages from causing stack overflows, CodedInputStream limits
/// how deeply messages may be nested. The default limit is 64.
/// </remarks>
public int SetRecursionLimit(int limit) {
if (limit < 0) {
throw new ArgumentOutOfRangeException("Recursion limit cannot be negative: " + limit);
}
int oldLimit = recursionLimit;
recursionLimit = limit;
return oldLimit;
}
/// <summary>
/// Set the maximum message size.
/// </summary>
/// <remarks>
/// In order to prevent malicious messages from exhausting memory or
/// causing integer overflows, CodedInputStream limits how large a message may be.
/// The default limit is 64MB. You should set this limit as small
/// as you can without harming your app's functionality. Note that
/// size limits only apply when reading from an InputStream, not
/// when constructed around a raw byte array (nor with ByteString.NewCodedInput).
/// </remarks>
public int SetSizeLimit(int limit) {
if (limit < 0) {
throw new ArgumentOutOfRangeException("Size limit cannot be negative: " + limit);
}
int oldLimit = sizeLimit;
sizeLimit = limit;
return oldLimit;
}
#region Internal reading and buffer management
/// <summary>
/// Sets currentLimit to (current position) + byteLimit. This is called
/// when descending into a length-delimited embedded message. The previous
/// limit is returned.
/// </summary>
/// <returns>The old limit.</returns>
public int PushLimit(int byteLimit) {
if (byteLimit < 0) {
throw InvalidProtocolBufferException.NegativeSize();
}
byteLimit += totalBytesRetired + bufferPos;
int oldLimit = currentLimit;
if (byteLimit > oldLimit) {
throw InvalidProtocolBufferException.TruncatedMessage();
}
currentLimit = byteLimit;
RecomputeBufferSizeAfterLimit();
return oldLimit;
}
private void RecomputeBufferSizeAfterLimit() {
bufferSize += bufferSizeAfterLimit;
int bufferEnd = totalBytesRetired + bufferSize;
if (bufferEnd > currentLimit) {
// Limit is in current buffer.
bufferSizeAfterLimit = bufferEnd - currentLimit;
bufferSize -= bufferSizeAfterLimit;
} else {
bufferSizeAfterLimit = 0;
}
}
/// <summary>
/// Discards the current limit, returning the previous limit.
/// </summary>
public void PopLimit(int oldLimit) {
currentLimit = oldLimit;
RecomputeBufferSizeAfterLimit();
}
/// <summary>
/// Called when buffer is empty to read more bytes from the
/// input. If <paramref name="mustSucceed"/> is true, RefillBuffer() gurantees that
/// either there will be at least one byte in the buffer when it returns
/// or it will throw an exception. If <paramref name="mustSucceed"/> is false,
/// RefillBuffer() returns false if no more bytes were available.
/// </summary>
/// <param name="mustSucceed"></param>
/// <returns></returns>
private bool RefillBuffer(bool mustSucceed) {
if (bufferPos < bufferSize) {
throw new InvalidOperationException("RefillBuffer() called when buffer wasn't empty.");
}
if (totalBytesRetired + bufferSize == currentLimit) {
// Oops, we hit a limit.
if (mustSucceed) {
throw InvalidProtocolBufferException.TruncatedMessage();
} else {
return false;
}
}
totalBytesRetired += bufferSize;
bufferPos = 0;
bufferSize = (input == null) ? 0 : input.Read(buffer, 0, buffer.Length);
if (bufferSize == 0) {
if (mustSucceed) {
throw InvalidProtocolBufferException.TruncatedMessage();
} else {
return false;
}
} else {
RecomputeBufferSizeAfterLimit();
int totalBytesRead =
totalBytesRetired + bufferSize + bufferSizeAfterLimit;
if (totalBytesRead > sizeLimit || totalBytesRead < 0) {
throw InvalidProtocolBufferException.SizeLimitExceeded();
}
return true;
}
}
/// <summary>
/// Read one byte from the input.
/// </summary>
/// <exception cref="InvalidProtocolBufferException">
/// he end of the stream or the current limit was reached
/// </exception>
public byte ReadRawByte() {
if (bufferPos == bufferSize) {
RefillBuffer(true);
}
return buffer[bufferPos++];
}
/// <summary>
/// Read a fixed size of bytes from the input.
/// </summary>
/// <exception cref="InvalidProtocolBufferException">
/// the end of the stream or the current limit was reached
/// </exception>
public byte[] ReadRawBytes(int size) {
if (size < 0) {
throw InvalidProtocolBufferException.NegativeSize();
}
if (totalBytesRetired + bufferPos + size > currentLimit) {
// Read to the end of the stream anyway.
SkipRawBytes(currentLimit - totalBytesRetired - bufferPos);
// Then fail.
throw InvalidProtocolBufferException.TruncatedMessage();
}
if (size <= bufferSize - bufferPos) {
// We have all the bytes we need already.
byte[] bytes = new byte[size];
Array.Copy(buffer, bufferPos, bytes, 0, size);
bufferPos += size;
return bytes;
} else if (size < BufferSize) {
// Reading more bytes than are in the buffer, but not an excessive number
// of bytes. We can safely allocate the resulting array ahead of time.
// First copy what we have.
byte[] bytes = new byte[size];
int pos = bufferSize - bufferPos;
Array.Copy(buffer, bufferPos, bytes, 0, pos);
bufferPos = bufferSize;
// We want to use RefillBuffer() and then copy from the buffer into our
// byte array rather than reading directly into our byte array because
// the input may be unbuffered.
RefillBuffer(true);
while (size - pos > bufferSize) {
Array.Copy(buffer, 0, bytes, pos, bufferSize);
pos += bufferSize;
bufferPos = bufferSize;
RefillBuffer(true);
}
Array.Copy(buffer, 0, bytes, pos, size - pos);
bufferPos = size - pos;
return bytes;
} else {
// The size is very large. For security reasons, we can't allocate the
// entire byte array yet. The size comes directly from the input, so a
// maliciously-crafted message could provide a bogus very large size in
// order to trick the app into allocating a lot of memory. We avoid this
// by allocating and reading only a small chunk at a time, so that the
// malicious message must actually *be* extremely large to cause
// problems. Meanwhile, we limit the allowed size of a message elsewhere.
// Remember the buffer markers since we'll have to copy the bytes out of
// it later.
int originalBufferPos = bufferPos;
int originalBufferSize = bufferSize;
// Mark the current buffer consumed.
totalBytesRetired += bufferSize;
bufferPos = 0;
bufferSize = 0;
// Read all the rest of the bytes we need.
int sizeLeft = size - (originalBufferSize - originalBufferPos);
List<byte[]> chunks = new List<byte[]>();
while (sizeLeft > 0) {
byte[] chunk = new byte[Math.Min(sizeLeft, BufferSize)];
int pos = 0;
while (pos < chunk.Length) {
int n = (input == null) ? -1 : input.Read(chunk, pos, chunk.Length - pos);
if (n <= 0) {
throw InvalidProtocolBufferException.TruncatedMessage();
}
totalBytesRetired += n;
pos += n;
}
sizeLeft -= chunk.Length;
chunks.Add(chunk);
}
// OK, got everything. Now concatenate it all into one buffer.
byte[] bytes = new byte[size];
// Start by copying the leftover bytes from this.buffer.
int newPos = originalBufferSize - originalBufferPos;
Array.Copy(buffer, originalBufferPos, bytes, 0, newPos);
// And now all the chunks.
foreach (byte[] chunk in chunks) {
Array.Copy(chunk, 0, bytes, newPos, chunk.Length);
newPos += chunk.Length;
}
// Done.
return bytes;
}
}
/// <summary>
/// Reads and discards a single field, given its tag value.
/// </summary>
/// <returns>false if the tag is an end-group tag, in which case
/// nothing is skipped. Otherwise, returns true.</returns>
public bool SkipField(uint tag) {
switch (WireFormat.GetTagWireType(tag)) {
case WireFormat.WireType.Varint:
ReadInt32();
return true;
case WireFormat.WireType.Fixed64:
ReadRawLittleEndian64();
return true;
case WireFormat.WireType.LengthDelimited:
SkipRawBytes((int) ReadRawVarint32());
return true;
case WireFormat.WireType.StartGroup:
SkipMessage();
CheckLastTagWas(
WireFormat.MakeTag(WireFormat.GetTagFieldNumber(tag),
WireFormat.WireType.EndGroup));
return true;
case WireFormat.WireType.EndGroup:
return false;
case WireFormat.WireType.Fixed32:
ReadRawLittleEndian32();
return true;
default:
throw InvalidProtocolBufferException.InvalidWireType();
}
}
/// <summary>
/// Reads and discards an entire message. This will read either until EOF
/// or until an endgroup tag, whichever comes first.
/// </summary>
public void SkipMessage() {
while (true) {
uint tag = ReadTag();
if (tag == 0 || !SkipField(tag)) {
return;
}
}
}
/// <summary>
/// Reads and discards <paramref name="size"/> bytes.
/// </summary>
/// <exception cref="InvalidProtocolBufferException">the end of the stream
/// or the current limit was reached</exception>
public void SkipRawBytes(int size) {
if (size < 0) {
throw InvalidProtocolBufferException.NegativeSize();
}
if (totalBytesRetired + bufferPos + size > currentLimit) {
// Read to the end of the stream anyway.
SkipRawBytes(currentLimit - totalBytesRetired - bufferPos);
// Then fail.
throw InvalidProtocolBufferException.TruncatedMessage();
}
if (size < bufferSize - bufferPos) {
// We have all the bytes we need already.
bufferPos += size;
} else {
// Skipping more bytes than are in the buffer. First skip what we have.
int pos = bufferSize - bufferPos;
totalBytesRetired += pos;
bufferPos = 0;
bufferSize = 0;
// Then skip directly from the InputStream for the rest.
if (pos < size) {
// TODO(jonskeet): Java implementation uses skip(). Not sure whether this is really equivalent...
if (input == null) {
throw InvalidProtocolBufferException.TruncatedMessage();
}
input.Seek(size - pos, SeekOrigin.Current);
if (input.Position > input.Length) {
throw InvalidProtocolBufferException.TruncatedMessage();
}
totalBytesRetired += size - pos;
}
}
}
#endregion
}
}

765
csharp/ProtocolBuffers/CodedOutputStream.cs
View file

@ -1,765 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.IO;
using System.Text;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers {
/// <summary>
/// Encodes and writes protocol message fields.
/// </summary>
/// <remarks>
/// This class contains two kinds of methods: methods that write specific
/// protocol message constructs and field types (e.g. WriteTag and
/// WriteInt32) and methods that write low-level values (e.g.
/// WriteRawVarint32 and WriteRawBytes). If you are writing encoded protocol
/// messages, you should use the former methods, but if you are writing some
/// other format of your own design, use the latter. The names of the former
/// methods are taken from the protocol buffer type names, not .NET types.
/// (Hence WriteFloat instead of WriteSingle, and WriteBool instead of WriteBoolean.)
/// </remarks>
public sealed class CodedOutputStream {
/// <summary>
/// The buffer size used by CreateInstance(Stream).
/// </summary>
public static readonly int DefaultBufferSize = 4096;
private readonly byte[] buffer;
private readonly int limit;
private int position;
private readonly Stream output;
#region Construction
private CodedOutputStream(byte[] buffer, int offset, int length) {
this.output = null;
this.buffer = buffer;
this.position = offset;
this.limit = offset + length;
}
private CodedOutputStream(Stream output, byte[] buffer) {
this.output = output;
this.buffer = buffer;
this.position = 0;
this.limit = buffer.Length;
}
/// <summary>
/// Creates a new CodedOutputStream which write to the given stream.
/// </summary>
public static CodedOutputStream CreateInstance(Stream output) {
return CreateInstance(output, DefaultBufferSize);
}
/// <summary>
/// Creates a new CodedOutputStream which write to the given stream and uses
/// the specified buffer size.
/// </summary>
public static CodedOutputStream CreateInstance(Stream output, int bufferSize) {
return new CodedOutputStream(output, new byte[bufferSize]);
}
/// <summary>
/// Creates a new CodedOutputStream that writes directly to the given
/// byte array. If more bytes are written than fit in the array,
/// OutOfSpaceException will be thrown.
/// </summary>
public static CodedOutputStream CreateInstance(byte[] flatArray) {
return CreateInstance(flatArray, 0, flatArray.Length);
}
/// <summary>
/// Creates a new CodedOutputStream that writes directly to the given
/// byte array slice. If more bytes are written than fit in the array,
/// OutOfSpaceException will be thrown.
/// </summary>
public static CodedOutputStream CreateInstance(byte[] flatArray, int offset, int length) {
return new CodedOutputStream(flatArray, offset, length);
}
#endregion
#region Writing of tags etc
/// <summary>
/// Writes a double field value, including tag, to the stream.
/// </summary>
public void WriteDouble(int fieldNumber, double value) {
// TODO(jonskeet): Test this on different endiannesses
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteRawLittleEndian64((ulong)BitConverter.DoubleToInt64Bits(value));
}
/// <summary>
/// Writes a float field value, including tag, to the stream.
/// </summary>
public void WriteFloat(int fieldNumber, float value) {
WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
// TODO(jonskeet): Test this on different endiannesses
byte[] rawBytes = BitConverter.GetBytes(value);
uint asInteger = BitConverter.ToUInt32(rawBytes, 0);
WriteRawLittleEndian32(asInteger);
}
/// <summary>
/// Writes a uint64 field value, including tag, to the stream.
/// </summary>
public void WriteUInt64(int fieldNumber, ulong value) {
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteRawVarint64(value);
}
/// <summary>
/// Writes an int64 field value, including tag, to the stream.
/// </summary>
public void WriteInt64(int fieldNumber, long value) {
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteRawVarint64((ulong)value);
}
/// <summary>
/// Writes an int32 field value, including tag, to the stream.
/// </summary>
public void WriteInt32(int fieldNumber, int value) {
WriteTag(fieldNumber, WireFormat.WireType.Varint);
if (value >= 0) {
WriteRawVarint32((uint)value);
} else {
// Must sign-extend.
WriteRawVarint64((ulong)value);
}
}
/// <summary>
/// Writes a fixed64 field value, including tag, to the stream.
/// </summary>
public void WriteFixed64(int fieldNumber, ulong value) {
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteRawLittleEndian64(value);
}
/// <summary>
/// Writes a fixed32 field value, including tag, to the stream.
/// </summary>
public void WriteFixed32(int fieldNumber, uint value) {
WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
WriteRawLittleEndian32(value);
}
/// <summary>
/// Writes a bool field value, including tag, to the stream.
/// </summary>
public void WriteBool(int fieldNumber, bool value) {
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteRawByte(value ? (byte)1 : (byte)0);
}
/// <summary>
/// Writes a string field value, including tag, to the stream.
/// </summary>
public void WriteString(int fieldNumber, string value) {
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
// Optimise the case where we have enough space to write
// the string directly to the buffer, which should be common.
int length = Encoding.UTF8.GetByteCount(value);
WriteRawVarint32((uint) length);
if (limit - position >= length) {
Encoding.UTF8.GetBytes(value, 0, value.Length, buffer, position);
position += length;
} else {
byte[] bytes = Encoding.UTF8.GetBytes(value);
WriteRawBytes(bytes);
}
}
/// <summary>
/// Writes a group field value, including tag, to the stream.
/// </summary>
public void WriteGroup(int fieldNumber, IMessage value) {
WriteTag(fieldNumber, WireFormat.WireType.StartGroup);
value.WriteTo(this);
WriteTag(fieldNumber, WireFormat.WireType.EndGroup);
}
public void WriteUnknownGroup(int fieldNumber, UnknownFieldSet value) {
WriteTag(fieldNumber, WireFormat.WireType.StartGroup);
value.WriteTo(this);
WriteTag(fieldNumber, WireFormat.WireType.EndGroup);
}
public void WriteMessage(int fieldNumber, IMessage value) {
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)value.SerializedSize);
value.WriteTo(this);
}
public void WriteBytes(int fieldNumber, ByteString value) {
// TODO(jonskeet): Optimise this! (No need to copy the bytes twice.)
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
byte[] bytes = value.ToByteArray();
WriteRawVarint32((uint)bytes.Length);
WriteRawBytes(bytes);
}
public void WriteUInt32(int fieldNumber, uint value) {
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteRawVarint32(value);
}
public void WriteEnum(int fieldNumber, int value) {
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteRawVarint32((uint)value);
}
public void WriteSFixed32(int fieldNumber, int value) {
WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
WriteRawLittleEndian32((uint)value);
}
public void WriteSFixed64(int fieldNumber, long value) {
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteRawLittleEndian64((ulong)value);
}
public void WriteSInt32(int fieldNumber, int value) {
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteRawVarint32(EncodeZigZag32(value));
}
public void WriteSInt64(int fieldNumber, long value) {
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteRawVarint64(EncodeZigZag64(value));
}
public void WriteMessageSetExtension(int fieldNumber, IMessage value) {
WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.StartGroup);
WriteUInt32(WireFormat.MessageSetField.TypeID, (uint)fieldNumber);
WriteMessage(WireFormat.MessageSetField.Message, value);
WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.EndGroup);
}
public void WriteRawMessageSetExtension(int fieldNumber, ByteString value) {
WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.StartGroup);
WriteUInt32(WireFormat.MessageSetField.TypeID, (uint)fieldNumber);
WriteBytes(WireFormat.MessageSetField.Message, value);
WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.EndGroup);
}
public void WriteField(FieldType fieldType, int fieldNumber, object value) {
switch (fieldType) {
case FieldType.Double: WriteDouble(fieldNumber, (double)value); break;
case FieldType.Float: WriteFloat(fieldNumber, (float)value); break;
case FieldType.Int64: WriteInt64(fieldNumber, (long)value); break;
case FieldType.UInt64: WriteUInt64(fieldNumber, (ulong)value); break;
case FieldType.Int32: WriteInt32(fieldNumber, (int)value); break;
case FieldType.Fixed64: WriteFixed64(fieldNumber, (ulong)value); break;
case FieldType.Fixed32: WriteFixed32(fieldNumber, (uint)value); break;
case FieldType.Bool: WriteBool(fieldNumber, (bool)value); break;
case FieldType.String: WriteString(fieldNumber, (string)value); break;
case FieldType.Group: WriteGroup(fieldNumber, (IMessage)value); break;
case FieldType.Message: WriteMessage(fieldNumber, (IMessage)value); break;
case FieldType.Bytes: WriteBytes(fieldNumber, (ByteString)value); break;
case FieldType.UInt32: WriteUInt32(fieldNumber, (uint)value); break;
case FieldType.SFixed32: WriteSFixed32(fieldNumber, (int)value); break;
case FieldType.SFixed64: WriteSFixed64(fieldNumber, (long)value); break;
case FieldType.SInt32: WriteSInt32(fieldNumber, (int)value); break;
case FieldType.SInt64: WriteSInt64(fieldNumber, (long)value); break;
case FieldType.Enum: WriteEnum(fieldNumber, ((EnumValueDescriptor)value).Number);
break;
}
}
#endregion
#region Underlying writing primitives
/// <summary>
/// Encodes and writes a tag.
/// </summary>
public void WriteTag(int fieldNumber, WireFormat.WireType type) {
WriteRawVarint32(WireFormat.MakeTag(fieldNumber, type));
}
private void SlowWriteRawVarint32(uint value) {
while (true) {
if ((value & ~0x7F) == 0) {
WriteRawByte(value);
return;
} else {
WriteRawByte((value & 0x7F) | 0x80);
value >>= 7;
}
}
}
/// <summary>
/// Writes a 32 bit value as a varint. The fast route is taken when
/// there's enough buffer space left to whizz through without checking
/// for each byte; otherwise, we resort to calling WriteRawByte each time.
/// </summary>
public void WriteRawVarint32(uint value) {
if (position + 5 > limit) {
SlowWriteRawVarint32(value);
return;
}
while (true) {
if ((value & ~0x7F) == 0) {
buffer[position++] = (byte) value;
return;
} else {
buffer[position++] = (byte)((value & 0x7F) | 0x80);
value >>= 7;
}
}
}
public void WriteRawVarint64(ulong value) {
while (true) {
if ((value & ~0x7FUL) == 0) {
WriteRawByte((uint)value);
return;
} else {
WriteRawByte(((uint)value & 0x7F) | 0x80);
value >>= 7;
}
}
}
public void WriteRawLittleEndian32(uint value) {
WriteRawByte((byte)value);
WriteRawByte((byte)(value >> 8));
WriteRawByte((byte)(value >> 16));
WriteRawByte((byte)(value >> 24));
}
public void WriteRawLittleEndian64(ulong value) {
WriteRawByte((byte)value);
WriteRawByte((byte)(value >> 8));
WriteRawByte((byte)(value >> 16));
WriteRawByte((byte)(value >> 24));
WriteRawByte((byte)(value >> 32));
WriteRawByte((byte)(value >> 40));
WriteRawByte((byte)(value >> 48));
WriteRawByte((byte)(value >> 56));
}
public void WriteRawByte(byte value) {
if (position == limit) {
RefreshBuffer();
}
buffer[position++] = value;
}
public void WriteRawByte(uint value) {
WriteRawByte((byte)value);
}
/// <summary>
/// Writes out an array of bytes.
/// </summary>
public void WriteRawBytes(byte[] value) {
WriteRawBytes(value, 0, value.Length);
}
/// <summary>
/// Writes out part of an array of bytes.
/// </summary>
public void WriteRawBytes(byte[] value, int offset, int length) {
if (limit - position >= length) {
Array.Copy(value, offset, buffer, position, length);
// We have room in the current buffer.
position += length;
} else {
// Write extends past current buffer. Fill the rest of this buffer and
// flush.
int bytesWritten = limit - position;
Array.Copy(value, offset, buffer, position, bytesWritten);
offset += bytesWritten;
length -= bytesWritten;
position = limit;
RefreshBuffer();
// Now deal with the rest.
// Since we have an output stream, this is our buffer
// and buffer offset == 0
if (length <= limit) {
// Fits in new buffer.
Array.Copy(value, offset, buffer, 0, length);
position = length;
} else {
// Write is very big. Let's do it all at once.
output.Write(value, offset, length);
}
}
}
#endregion
#region Size computations
const int LittleEndian64Size = 8;
const int LittleEndian32Size = 4;
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// double field, including the tag.
/// </summary>
public static int ComputeDoubleSize(int fieldNumber, double value) {
return ComputeTagSize(fieldNumber) + LittleEndian64Size;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// float field, including the tag.
/// </summary>
public static int ComputeFloatSize(int fieldNumber, float value) {
return ComputeTagSize(fieldNumber) + LittleEndian32Size;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// uint64 field, including the tag.
/// </summary>
public static int ComputeUInt64Size(int fieldNumber, ulong value) {
return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size(value);
}
/// <summary>
/// Compute the number of bytes that would be needed to encode an
/// int64 field, including the tag.
/// </summary>
public static int ComputeInt64Size(int fieldNumber, long value) {
return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size((ulong)value);
}
/// <summary>
/// Compute the number of bytes that would be needed to encode an
/// int32 field, including the tag.
/// </summary>
public static int ComputeInt32Size(int fieldNumber, int value) {
if (value >= 0) {
return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint)value);
} else {
// Must sign-extend.
return ComputeTagSize(fieldNumber) + 10;
}
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// fixed64 field, including the tag.
/// </summary>
public static int ComputeFixed64Size(int fieldNumber, ulong value) {
return ComputeTagSize(fieldNumber) + LittleEndian64Size;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// fixed32 field, including the tag.
/// </summary>
public static int ComputeFixed32Size(int fieldNumber, uint value) {
return ComputeTagSize(fieldNumber) + LittleEndian32Size;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// bool field, including the tag.
/// </summary>
public static int ComputeBoolSize(int fieldNumber, bool value) {
return ComputeTagSize(fieldNumber) + 1;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// string field, including the tag.
/// </summary>
public static int ComputeStringSize(int fieldNumber, String value) {
int byteArraySize = Encoding.UTF8.GetByteCount(value);
return ComputeTagSize(fieldNumber) +
ComputeRawVarint32Size((uint)byteArraySize) +
byteArraySize;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// group field, including the tag.
/// </summary>
public static int ComputeGroupSize(int fieldNumber, IMessage value) {
return ComputeTagSize(fieldNumber) * 2 + value.SerializedSize;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// group field represented by an UnknownFieldSet, including the tag.
/// </summary>
public static int ComputeUnknownGroupSize(int fieldNumber,
UnknownFieldSet value) {
return ComputeTagSize(fieldNumber) * 2 + value.SerializedSize;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode an
/// embedded message field, including the tag.
/// </summary>
public static int ComputeMessageSize(int fieldNumber, IMessage value) {
int size = value.SerializedSize;
return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint)size) + size;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// bytes field, including the tag.
/// </summary>
public static int ComputeBytesSize(int fieldNumber, ByteString value) {
return ComputeTagSize(fieldNumber) +
ComputeRawVarint32Size((uint)value.Length) +
value.Length;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// uint32 field, including the tag.
/// </summary>
public static int ComputeUInt32Size(int fieldNumber, uint value) {
return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size(value);
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// enum field, including the tag. The caller is responsible for
/// converting the enum value to its numeric value.
/// </summary>
public static int ComputeEnumSize(int fieldNumber, int value) {
return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint)value);
}
/// <summary>
/// Compute the number of bytes that would be needed to encode an
/// sfixed32 field, including the tag.
/// </summary>
public static int ComputeSFixed32Size(int fieldNumber, int value) {
return ComputeTagSize(fieldNumber) + LittleEndian32Size;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode an
/// sfixed64 field, including the tag.
/// </summary>
public static int ComputeSFixed64Size(int fieldNumber, long value) {
return ComputeTagSize(fieldNumber) + LittleEndian64Size;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode an
/// sint32 field, including the tag.
/// </summary>
public static int ComputeSInt32Size(int fieldNumber, int value) {
return ComputeTagSize(fieldNumber) +
ComputeRawVarint32Size(EncodeZigZag32(value));
}
/// <summary>
/// Compute the number of bytes that would be needed to encode an
/// sint64 field, including the tag.
/// </summary>
public static int ComputeSInt64Size(int fieldNumber, long value) {
return ComputeTagSize(fieldNumber) +
ComputeRawVarint64Size(EncodeZigZag64(value));
}
/*
* Compute the number of bytes that would be needed to encode a
* MessageSet extension to the stream. For historical reasons,
* the wire format differs from normal fields.
*/
/// <summary>
/// Compute the number of bytes that would be needed to encode a
/// MessageSet extension to the stream. For historical reasons,
/// the wire format differs from normal fields.
/// </summary>
public static int ComputeMessageSetExtensionSize(int fieldNumber, IMessage value) {
return ComputeTagSize(WireFormat.MessageSetField.Item) * 2 +
ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) +
ComputeMessageSize(WireFormat.MessageSetField.Message, value);
}
/// <summary>
/// Compute the number of bytes that would be needed to encode an
/// unparsed MessageSet extension field to the stream. For
/// historical reasons, the wire format differs from normal fields.
/// </summary>
public static int ComputeRawMessageSetExtensionSize(int fieldNumber, ByteString value) {
return ComputeTagSize(WireFormat.MessageSetField.Item) * 2 +
ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) +
ComputeBytesSize(WireFormat.MessageSetField.Message, value);
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a varint.
/// </summary>
public static int ComputeRawVarint32Size(uint value) {
if ((value & (0xffffffff << 7)) == 0) return 1;
if ((value & (0xffffffff << 14)) == 0) return 2;
if ((value & (0xffffffff << 21)) == 0) return 3;
if ((value & (0xffffffff << 28)) == 0) return 4;
return 5;
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a varint.
/// </summary>
public static int ComputeRawVarint64Size(ulong value) {
if ((value & (0xffffffffffffffffL << 7)) == 0) return 1;
if ((value & (0xffffffffffffffffL << 14)) == 0) return 2;
if ((value & (0xffffffffffffffffL << 21)) == 0) return 3;
if ((value & (0xffffffffffffffffL << 28)) == 0) return 4;
if ((value & (0xffffffffffffffffL << 35)) == 0) return 5;
if ((value & (0xffffffffffffffffL << 42)) == 0) return 6;
if ((value & (0xffffffffffffffffL << 49)) == 0) return 7;
if ((value & (0xffffffffffffffffL << 56)) == 0) return 8;
if ((value & (0xffffffffffffffffL << 63)) == 0) return 9;
return 10;
}
/*
* Compute the number of bytes that would be needed to encode a
* field of arbitrary type, including tag, to the stream.
*
* @param type The field's type.
* @param number The field's number.
* @param value Object representing the field's value. Must be of the exact
* type which would be returned by
* {@link Message#getField(FieldDescriptor)} for
* this field.
*/
public static int ComputeFieldSize(FieldType fieldType, int fieldNumber, Object value) {
switch (fieldType) {
case FieldType.Double: return ComputeDoubleSize(fieldNumber, (double)value);
case FieldType.Float: return ComputeFloatSize(fieldNumber, (float)value);
case FieldType.Int64: return ComputeInt64Size(fieldNumber, (long)value);
case FieldType.UInt64: return ComputeUInt64Size(fieldNumber, (ulong)value);
case FieldType.Int32: return ComputeInt32Size(fieldNumber, (int)value);
case FieldType.Fixed64: return ComputeFixed64Size(fieldNumber, (ulong)value);
case FieldType.Fixed32: return ComputeFixed32Size(fieldNumber, (uint)value);
case FieldType.Bool: return ComputeBoolSize(fieldNumber, (bool)value);
case FieldType.String: return ComputeStringSize(fieldNumber, (string)value);
case FieldType.Group: return ComputeGroupSize(fieldNumber, (IMessage)value);
case FieldType.Message: return ComputeMessageSize(fieldNumber, (IMessage)value);
case FieldType.Bytes: return ComputeBytesSize(fieldNumber, (ByteString)value);
case FieldType.UInt32: return ComputeUInt32Size(fieldNumber, (uint)value);
case FieldType.SFixed32: return ComputeSFixed32Size(fieldNumber, (int)value);
case FieldType.SFixed64: return ComputeSFixed64Size(fieldNumber, (long)value);
case FieldType.SInt32: return ComputeSInt32Size(fieldNumber, (int)value);
case FieldType.SInt64: return ComputeSInt64Size(fieldNumber, (long)value);
case FieldType.Enum: return ComputeEnumSize(fieldNumber, ((EnumValueDescriptor)value).Number);
default:
throw new ArgumentOutOfRangeException("Invalid field type " + fieldType);
}
}
/// <summary>
/// Compute the number of bytes that would be needed to encode a tag.
/// </summary>
public static int ComputeTagSize(int fieldNumber) {
return ComputeRawVarint32Size(WireFormat.MakeTag(fieldNumber, 0));
}
#endregion
/// <summary>
/// Encode a 32-bit value with ZigZag encoding.
/// </summary>
/// <remarks>
/// ZigZag encodes signed integers into values that can be efficiently
/// encoded with varint. (Otherwise, negative values must be
/// sign-extended to 64 bits to be varint encoded, thus always taking
/// 10 bytes on the wire.)
/// </remarks>
public static uint EncodeZigZag32(int n) {
// Note: the right-shift must be arithmetic
return (uint)((n << 1) ^ (n >> 31));
}
/// <summary>
/// Encode a 64-bit value with ZigZag encoding.
/// </summary>
/// <remarks>
/// ZigZag encodes signed integers into values that can be efficiently
/// encoded with varint. (Otherwise, negative values must be
/// sign-extended to 64 bits to be varint encoded, thus always taking
/// 10 bytes on the wire.)
/// </remarks>
public static ulong EncodeZigZag64(long n) {
return (ulong)((n << 1) ^ (n >> 63));
}
private void RefreshBuffer() {
if (output == null) {
// We're writing to a single buffer.
throw new OutOfSpaceException();
}
// Since we have an output stream, this is our buffer
// and buffer offset == 0
output.Write(buffer, 0, position);
position = 0;
}
/// <summary>
/// Indicates that a CodedOutputStream wrapping a flat byte array
/// ran out of space.
/// </summary>
public sealed class OutOfSpaceException : IOException {
internal OutOfSpaceException()
: base("CodedOutputStream was writing to a flat byte array and ran out of space.") {
}
}
public void Flush() {
if (output != null) {
RefreshBuffer();
}
}
/// <summary>
/// Verifies that SpaceLeft returns zero. It's common to create a byte array
/// that is exactly big enough to hold a message, then write to it with
/// a CodedOutputStream. Calling CheckNoSpaceLeft after writing verifies that
/// the message was actually as big as expected, which can help bugs.
/// </summary>
public void CheckNoSpaceLeft() {
if (SpaceLeft != 0) {
throw new InvalidOperationException("Did not write as much data as expected.");
}
}
/// <summary>
/// If writing to a flat array, returns the space left in the array. Otherwise,
/// throws an InvalidOperationException.
/// </summary>
public int SpaceLeft {
get {
if (output == null) {
return limit - position;
} else {
throw new InvalidOperationException(
"SpaceLeft can only be called on CodedOutputStreams that are " +
"writing to a flat array.");
}
}
}
}
}

108
csharp/ProtocolBuffers/Collections/Dictionaries.cs
View file

@ -1,108 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections;
using System.Collections.Generic;
namespace Google.ProtocolBuffers.Collections {
/// <summary>
/// Non-generic class with generic methods which proxy to the non-generic methods
/// in the generic class.
/// </summary>
public static class Dictionaries {
/// <summary>
/// Compares two dictionaries for equality. Each value is compared with equality using Equals
/// for non-IEnumerable implementations, and using EnumerableEquals otherwise.
/// TODO(jonskeet): This is clearly pretty slow, and involves lots of boxing/unboxing...
/// </summary>
public static bool Equals<TKey, TValue>(IDictionary<TKey, TValue> left, IDictionary<TKey, TValue> right) {
if (left.Count != right.Count) {
return false;
}
foreach (KeyValuePair<TKey,TValue> leftEntry in left)
{
TValue rightValue;
if (!right.TryGetValue(leftEntry.Key, out rightValue)) {
return false;
}
IEnumerable leftEnumerable = leftEntry.Value as IEnumerable;
IEnumerable rightEnumerable = rightValue as IEnumerable;
if (leftEnumerable == null || rightEnumerable == null) {
if (!object.Equals(leftEntry.Value, rightValue)) {
return false;
}
} else {
IEnumerator leftEnumerator = leftEnumerable.GetEnumerator();
try {
foreach (object rightObject in rightEnumerable) {
if (!leftEnumerator.MoveNext()) {
return false;
}
if (!object.Equals(leftEnumerator.Current, rightObject)) {
return false;
}
}
if (leftEnumerator.MoveNext()) {
return false;
}
} finally {
if (leftEnumerator is IDisposable) {
((IDisposable)leftEnumerator).Dispose();
}
}
}
}
return true;
}
public static IDictionary<TKey, TValue> AsReadOnly<TKey, TValue> (IDictionary<TKey, TValue> dictionary) {
return dictionary.IsReadOnly ? dictionary : new ReadOnlyDictionary<TKey, TValue>(dictionary);
}
/// <summary>
/// Creates a hashcode for a dictionary by XORing the hashcodes of all the fields
/// and values. (By XORing, we avoid ordering issues.)
/// TODO(jonskeet): Currently XORs other stuff too, and assumes non-null values.
/// </summary>
public static int GetHashCode<TKey, TValue>(IDictionary<TKey, TValue> dictionary) {
int ret = 31;
foreach (KeyValuePair<TKey, TValue> entry in dictionary) {
int hash = entry.Key.GetHashCode() ^ GetDeepHashCode(entry.Value);
ret ^= hash;
}
return ret;
}
/// <summary>
/// Determines the hash of a value by either taking it directly or hashing all the elements
/// for IEnumerable implementations.
/// </summary>
private static int GetDeepHashCode(object value) {
IEnumerable iterable = value as IEnumerable;
if (iterable == null) {
return value.GetHashCode();
}
int hash = 29;
foreach (object element in iterable) {
hash = hash * 37 + element.GetHashCode();
}
return hash;
}
}
}

56
csharp/ProtocolBuffers/Collections/Lists.cs
View file

@ -1,56 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.Collections.Generic;
using System.Collections.ObjectModel;
namespace Google.ProtocolBuffers.Collections {
/// <summary>
/// Utility non-generic class for calling into Lists{T} using type inference.
/// </summary>
public static class Lists {
/// <summary>
/// Returns a read-only view of the specified list.
/// </summary>
public static IList<T> AsReadOnly<T>(IList<T> list) {
return Lists<T>.AsReadOnly(list);
}
}
/// <summary>
/// Utility class for dealing with lists.
/// </summary>
public static class Lists<T> {
static readonly ReadOnlyCollection<T> empty = new ReadOnlyCollection<T>(new T[0]);
/// <summary>
/// Returns an immutable empty list.
/// </summary>
public static ReadOnlyCollection<T> Empty {
get { return empty; }
}
/// <summary>
/// Returns either the original reference if it's already read-only,
/// or a new ReadOnlyCollection wrapping the original list.
/// </summary>
public static IList<T> AsReadOnly(IList<T> list) {
return list.IsReadOnly ? list : new ReadOnlyCollection<T>(list);
}
}
}

95
csharp/ProtocolBuffers/Collections/PopsicleList.cs
View file

@ -1,95 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace Google.ProtocolBuffers.Collections {
/// <summary>
/// Proxies calls to a <see cref="List{T}" />, but allows the list
/// to be made read-only (with the <see cref="MakeReadOnly" /> method),
/// after which any modifying methods throw <see cref="NotSupportedException" />.
/// </summary>
public sealed class PopsicleList<T> : IList<T> {
private readonly List<T> items = new List<T>();
private bool readOnly = false;
/// <summary>
/// Makes this list read-only ("freezes the popsicle"). From this
/// point on, mutating methods (Clear, Add etc) will throw a
/// NotSupportedException. There is no way of "defrosting" the list afterwards.
/// </summary>
public void MakeReadOnly() {
readOnly = true;
}
public int IndexOf(T item) {
return items.IndexOf(item);
}
public void Insert(int index, T item) {
ValidateModification();
items.Insert(index, item);
}
public void RemoveAt(int index) {
ValidateModification();
items.RemoveAt(index);
}
public T this[int index] {
get {
return items[index];
}
set {
ValidateModification();
items[index] = value;
}
}
public void Add(T item) {
ValidateModification();
items.Add(item);
}
public void Clear() {
ValidateModification();
items.Clear();
}
public bool Contains(T item) {
return items.Contains(item);
}
public void CopyTo(T[] array, int arrayIndex) {
items.CopyTo(array, arrayIndex);
}
public int Count {
get { return items.Count; }
}
public bool IsReadOnly {
get { return readOnly; }
}
public bool Remove(T item) {
ValidateModification();
return items.Remove(item);
}
public IEnumerator<T> GetEnumerator() {
return items.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}
private void ValidateModification() {
if (readOnly) {
throw new NotSupportedException("List is read-only");
}
}
}
}

112
csharp/ProtocolBuffers/Collections/ReadOnlyDictionary.cs
View file

@ -1,112 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections;
using System.Collections.Generic;
namespace Google.ProtocolBuffers.Collections {
/// <summary>
/// Read-only wrapper around another dictionary.
/// </summary>
public sealed class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue> {
readonly IDictionary<TKey, TValue> wrapped;
public ReadOnlyDictionary(IDictionary<TKey, TValue> wrapped) {
this.wrapped = wrapped;
}
public void Add(TKey key, TValue value) {
throw new InvalidOperationException();
}
public bool ContainsKey(TKey key) {
return wrapped.ContainsKey(key);
}
public ICollection<TKey> Keys {
get { return wrapped.Keys; }
}
public bool Remove(TKey key) {
throw new InvalidOperationException();
}
public bool TryGetValue(TKey key, out TValue value) {
return wrapped.TryGetValue(key, out value);
}
public ICollection<TValue> Values {
get { return wrapped.Values; }
}
public TValue this[TKey key] {
get {
return wrapped[key];
}
set {
throw new InvalidOperationException();
}
}
public void Add(KeyValuePair<TKey, TValue> item) {
throw new InvalidOperationException();
}
public void Clear() {
throw new InvalidOperationException();
}
public bool Contains(KeyValuePair<TKey, TValue> item) {
return wrapped.Contains(item);
}
public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) {
wrapped.CopyTo(array, arrayIndex);
}
public int Count {
get { return wrapped.Count; }
}
public bool IsReadOnly {
get { return true; }
}
public bool Remove(KeyValuePair<TKey, TValue> item) {
throw new InvalidOperationException();
}
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() {
return wrapped.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator() {
return ((IEnumerable) wrapped).GetEnumerator();
}
public override bool Equals(object obj) {
return wrapped.Equals(obj);
}
public override int GetHashCode() {
return wrapped.GetHashCode();
}
public override string ToString() {
return wrapped.ToString();
}
}
}

32
csharp/ProtocolBuffers/Delegates.cs
View file

@ -1,32 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.IO;
namespace Google.ProtocolBuffers {
/// <summary>
/// Delegate to return a stream when asked, used by MessageStreamIterator.
/// </summary>
public delegate Stream StreamProvider();
// These delegate declarations mirror the ones in .NET 3.5 for the sake of familiarity.
internal delegate TResult Func<TResult>();
internal delegate TResult Func<T, TResult>(T arg);
internal delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);
internal delegate TResult Func<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3);
internal delegate TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
internal delegate void Action();
internal delegate void Action<T1, T2>(T1 arg1, T2 arg2);
}

49
csharp/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs
View file

@ -1,49 +0,0 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.DescriptorProtos {
public static partial class CSharpOptions {
#region Descriptor
public static pbd::FileDescriptor Descriptor {
get { return descriptor; }
}
private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom(
global::System.Convert.FromBase64String(
"CiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8SD2dvb2ds" +
"ZS5wcm90b2J1ZhogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG86" +
"NwoPQ1NoYXJwTmFtZXNwYWNlEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRp" +
"b25zGKCcASABKAk6PwoXQ1NoYXJwVW1icmVsbGFDbGFzc25hbWUSHC5nb29n" +
"bGUucHJvdG9idWYuRmlsZU9wdGlvbnMYoZwBIAEoCTo7ChNDU2hhcnBNdWx0" +
"aXBsZUZpbGVzEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKKcASAB" +
"KAg6OQoRQ1NoYXJwTmVzdENsYXNzZXMSHC5nb29nbGUucHJvdG9idWYuRmls" +
"ZU9wdGlvbnMYo5wBIAEoCDo7ChNDU2hhcnBQdWJsaWNDbGFzc2VzEhwuZ29v" +
"Z2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKScASABKAhCPILiCSdHb29nbGUu" +
"UHJvdG9jb2xCdWZmZXJzLkRlc2NyaXB0b3JQcm90b3OK4gkNQ1NoYXJwT3B0" +
"aW9ucw=="),
new pbd::FileDescriptor[] {
global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor,
});
#endregion
#region Extensions
public static readonly pb::GeneratedExtensionBase<string> CSharpNamespace =
pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[0]);
public static readonly pb::GeneratedExtensionBase<string> CSharpUmbrellaClassname =
pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[1]);
public static readonly pb::GeneratedExtensionBase<bool> CSharpMultipleFiles =
pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[2]);
public static readonly pb::GeneratedExtensionBase<bool> CSharpNestClasses =
pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[3]);
public static readonly pb::GeneratedExtensionBase<bool> CSharpPublicClasses =
pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[4]);
#endregion
#region Static variables
#endregion
}
}

6124
csharp/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
View file

File diff suppressed because it is too large Load diff

36
csharp/ProtocolBuffers/DescriptorProtos/IDescriptorProto.cs
View file

@ -1,36 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
namespace Google.ProtocolBuffers.DescriptorProtos {
/// <summary>
/// Interface implemented by all DescriptorProtos. The generator doesn't
/// emit the interface implementation claim, so PartialClasses.cs contains
/// partial class declarations for each of them.
/// </summary>
/// <typeparam name="TOptions">The associated options protocol buffer type</typeparam>
public interface IDescriptorProto<TOptions> {
/// <summary>
/// The brief name of the descriptor's target.
/// </summary>
string Name { get; }
/// <summary>
/// The options for this descriptor.
/// </summary>
TOptions Options { get; }
}
}

43
csharp/ProtocolBuffers/DescriptorProtos/PartialClasses.cs
View file

@ -1,43 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
// This file just contains partial classes for each of the
// autogenerated classes, so that they implement
// IDescriptorProto
namespace Google.ProtocolBuffers.DescriptorProtos {
// TODO(jonskeet): Find a better way of fixing this. It's needed in order to
// cope with unknown fields during initialization.
public partial class DescriptorProtoFile {
private static readonly bool initialized = false;
internal static bool Bootstrapping {
get { return !initialized; }
}
static DescriptorProtoFile() {
initialized = true;
}
}
public partial class DescriptorProto : IDescriptorProto<MessageOptions> { }
public partial class EnumDescriptorProto : IDescriptorProto<EnumOptions> { }
public partial class EnumValueDescriptorProto : IDescriptorProto<EnumValueOptions> { }
public partial class FieldDescriptorProto : IDescriptorProto<FieldOptions> { }
public partial class FileDescriptorProto : IDescriptorProto<FileOptions> { }
public partial class MethodDescriptorProto : IDescriptorProto<MethodOptions> { }
public partial class ServiceDescriptorProto : IDescriptorProto<ServiceOptions> { }
}

83
csharp/ProtocolBuffers/Descriptors/DescriptorBase.cs
View file

@ -1,83 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Base class for nearly all descriptors, providing common functionality.
/// </summary>
/// <typeparam name="TProto">Type of the protocol buffer form of this descriptor</typeparam>
/// <typeparam name="TOptions">Type of the options protocol buffer for this descriptor</typeparam>
public abstract class DescriptorBase<TProto, TOptions> : IDescriptor<TProto>
where TProto : IMessage, IDescriptorProto<TOptions> {
private readonly TProto proto;
private readonly FileDescriptor file;
private readonly string fullName;
protected DescriptorBase(TProto proto, FileDescriptor file, string fullName) {
this.proto = proto;
this.file = file;
this.fullName = fullName;
}
protected static string ComputeFullName(FileDescriptor file, MessageDescriptor parent, string name) {
if (parent != null) {
return parent.FullName + "." + name;
}
if (file.Package.Length > 0) {
return file.Package + "." + name;
}
return name;
}
IMessage IDescriptor.Proto {
get { return proto; }
}
/// <summary>
/// Returns the protocol buffer form of this descriptor
/// </summary>
public TProto Proto {
get { return proto; }
}
public TOptions Options {
get { return proto.Options; }
}
/// <summary>
/// The fully qualified name of the descriptor's target.
/// </summary>
public string FullName {
get { return fullName; }
}
/// <summary>
/// The brief name of the descriptor's target.
/// </summary>
public string Name {
get { return proto.Name; }
}
/// <value>
/// The file this descriptor was declared in.
/// </value>
public FileDescriptor File {
get { return file; }
}
}
}

281
csharp/ProtocolBuffers/Descriptors/DescriptorPool.cs
View file

@ -1,281 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.Collections.Generic;
using System;
using System.Text;
using System.Text.RegularExpressions;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Contains lookup tables containing all the descriptors defined in a particular file.
/// </summary>
internal sealed class DescriptorPool {
private readonly IDictionary<string, IDescriptor> descriptorsByName =
new Dictionary<string, IDescriptor>();
private readonly IDictionary<DescriptorIntPair, FieldDescriptor> fieldsByNumber =
new Dictionary<DescriptorIntPair, FieldDescriptor>();
private readonly IDictionary<DescriptorIntPair, EnumValueDescriptor> enumValuesByNumber =
new Dictionary<DescriptorIntPair, EnumValueDescriptor>();
private readonly DescriptorPool[] dependencies;
internal DescriptorPool(FileDescriptor[] dependencyFiles) {
dependencies = new DescriptorPool[dependencyFiles.Length];
for (int i = 0; i < dependencyFiles.Length; i++) {
dependencies[i] = dependencyFiles[i].DescriptorPool;
}
foreach (FileDescriptor dependency in dependencyFiles) {
AddPackage(dependency.Package, dependency);
}
}
/// <summary>
/// Finds a symbol of the given name within the pool.
/// </summary>
/// <typeparam name="T">The type of symbol to look for</typeparam>
/// <param name="fullName">Fully-qualified name to look up</param>
/// <returns>The symbol with the given name and type,
/// or null if the symbol doesn't exist or has the wrong type</returns>
internal T FindSymbol<T>(string fullName) where T : class, IDescriptor {
IDescriptor result;
descriptorsByName.TryGetValue(fullName, out result);
T descriptor = result as T;
if (descriptor != null) {
return descriptor;
}
foreach (DescriptorPool dependency in dependencies) {
dependency.descriptorsByName.TryGetValue(fullName, out result);
descriptor = result as T;
if (descriptor != null) {
return descriptor;
}
}
return null;
}
/// <summary>
/// Adds a package to the symbol tables. If a package by the same name
/// already exists, that is fine, but if some other kind of symbol
/// exists under the same name, an exception is thrown. If the package
/// has multiple components, this also adds the parent package(s).
/// </summary>
internal void AddPackage(string fullName, FileDescriptor file) {
int dotpos = fullName.LastIndexOf('.');
String name;
if (dotpos != -1) {
AddPackage(fullName.Substring(0, dotpos), file);
name = fullName.Substring(dotpos + 1);
} else {
name = fullName;
}
IDescriptor old;
if (descriptorsByName.TryGetValue(fullName, out old)) {
if (!(old is PackageDescriptor)) {
throw new DescriptorValidationException(file,
"\"" + name + "\" is already defined (as something other than a " +
"package) in file \"" + old.File.Name + "\".");
}
}
// TODO(jonskeet): Check issue 25 wrt the ordering of these parameters
descriptorsByName[fullName] = new PackageDescriptor(fullName, name, file);
}
/// <summary>
/// Adds a symbol to the symbol table.
/// </summary>
/// <exception cref="DescriptorValidationException">The symbol already existed
/// in the symbol table.</exception>
internal void AddSymbol(IDescriptor descriptor) {
ValidateSymbolName(descriptor);
String fullName = descriptor.FullName;
IDescriptor old;
if (descriptorsByName.TryGetValue(fullName, out old)) {
int dotPos = fullName.LastIndexOf('.');
string message;
if (descriptor.File == old.File) {
if (dotPos == -1) {
message = "\"" + fullName + "\" is already defined.";
} else {
message = "\"" + fullName.Substring(dotPos + 1) + "\" is already defined in \"" + fullName.Substring(0, dotPos) + "\".";
}
} else {
message = "\"" + fullName + "\" is already defined in file \"" + old.File.Name + "\".";
}
throw new DescriptorValidationException(descriptor, message);
}
descriptorsByName[fullName] = descriptor;
}
private static readonly Regex ValidationRegex = new Regex("^[_A-Za-z][_A-Za-z0-9]*$", RegexOptions.Compiled);
/// <summary>
/// Verifies that the descriptor's name is valid (i.e. it contains
/// only letters, digits and underscores, and does not start with a digit).
/// </summary>
/// <param name="descriptor"></param>
private static void ValidateSymbolName(IDescriptor descriptor) {
if (descriptor.Name == "") {
throw new DescriptorValidationException(descriptor, "Missing name.");
}
if (!ValidationRegex.IsMatch(descriptor.Name)) {
throw new DescriptorValidationException(descriptor,
"\"" + descriptor.Name + "\" is not a valid identifier.");
}
}
/// <summary>
/// Returns the field with the given number in the given descriptor,
/// or null if it can't be found.
/// </summary>
internal FieldDescriptor FindFieldByNumber(MessageDescriptor messageDescriptor, int number) {
FieldDescriptor ret;
fieldsByNumber.TryGetValue(new DescriptorIntPair(messageDescriptor, number), out ret);
return ret;
}
internal EnumValueDescriptor FindEnumValueByNumber(EnumDescriptor enumDescriptor, int number) {
EnumValueDescriptor ret;
enumValuesByNumber.TryGetValue(new DescriptorIntPair(enumDescriptor, number), out ret);
return ret;
}
/// <summary>
/// Adds a field to the fieldsByNumber table.
/// </summary>
/// <exception cref="DescriptorValidationException">A field with the same
/// containing type and number already exists.</exception>
internal void AddFieldByNumber(FieldDescriptor field) {
DescriptorIntPair key = new DescriptorIntPair(field.ContainingType, field.FieldNumber);
FieldDescriptor old;
if (fieldsByNumber.TryGetValue(key, out old)) {
throw new DescriptorValidationException(field, "Field number " + field.FieldNumber +
"has already been used in \"" + field.ContainingType.FullName +
"\" by field \"" + old.Name + "\".");
}
fieldsByNumber[key] = field;
}
/// <summary>
/// Adds an enum value to the enumValuesByNumber table. If an enum value
/// with the same type and number already exists, this method does nothing.
/// (This is allowed; the first value defined with the number takes precedence.)
/// </summary>
internal void AddEnumValueByNumber(EnumValueDescriptor enumValue) {
DescriptorIntPair key = new DescriptorIntPair(enumValue.EnumDescriptor, enumValue.Number);
if (!enumValuesByNumber.ContainsKey(key)) {
enumValuesByNumber[key] = enumValue;
}
}
/// <summary>
/// Looks up a descriptor by name, relative to some other descriptor.
/// The name may be fully-qualified (with a leading '.'), partially-qualified,
/// or unqualified. C++-like name lookup semantics are used to search for the
/// matching descriptor.
/// </summary>
public IDescriptor LookupSymbol(string name, IDescriptor relativeTo) {
// TODO(jonskeet): This could be optimized in a number of ways.
IDescriptor result;
if (name.StartsWith(".")) {
// Fully-qualified name.
result = FindSymbol<IDescriptor>(name.Substring(1));
} else {
// If "name" is a compound identifier, we want to search for the
// first component of it, then search within it for the rest.
int firstPartLength = name.IndexOf('.');
string firstPart = firstPartLength == -1 ? name : name.Substring(0, firstPartLength);
// We will search each parent scope of "relativeTo" looking for the
// symbol.
StringBuilder scopeToTry = new StringBuilder(relativeTo.FullName);
while (true) {
// Chop off the last component of the scope.
// TODO(jonskeet): Make this more efficient. May not be worth using StringBuilder at all
int dotpos = scopeToTry.ToString().LastIndexOf(".");
if (dotpos == -1) {
result = FindSymbol<IDescriptor>(name);
break;
} else {
scopeToTry.Length = dotpos + 1;
// Append firstPart and try to find.
scopeToTry.Append(firstPart);
result = FindSymbol<IDescriptor>(scopeToTry.ToString());
if (result != null) {
if (firstPartLength != -1) {
// We only found the first part of the symbol. Now look for
// the whole thing. If this fails, we *don't* want to keep
// searching parent scopes.
scopeToTry.Length = dotpos + 1;
scopeToTry.Append(name);
result = FindSymbol<IDescriptor>(scopeToTry.ToString());
}
break;
}
// Not found. Remove the name so we can try again.
scopeToTry.Length = dotpos;
}
}
}
if (result == null) {
throw new DescriptorValidationException(relativeTo, "\"" + name + "\" is not defined.");
} else {
return result;
}
}
/// <summary>
/// Struct used to hold the keys for the fieldByNumber table.
/// </summary>
struct DescriptorIntPair : IEquatable<DescriptorIntPair> {
private readonly int number;
private readonly IDescriptor descriptor;
internal DescriptorIntPair(IDescriptor descriptor, int number) {
this.number = number;
this.descriptor = descriptor;
}
public bool Equals(DescriptorIntPair other) {
return descriptor == other.descriptor
&& number == other.number;
}
public override bool Equals(object obj) {
if (obj is DescriptorIntPair) {
return Equals((DescriptorIntPair)obj);
}
return false;
}
public override int GetHashCode() {
return descriptor.GetHashCode() * ((1 << 16) - 1) + number;
}
}
}
}

43
csharp/ProtocolBuffers/Descriptors/DescriptorUtil.cs
View file

@ -1,43 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.Collections.Generic;
using Google.ProtocolBuffers.Collections;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Internal class containing utility methods when working with descriptors.
/// </summary>
internal static class DescriptorUtil {
/// <summary>
/// Equivalent to Func[TInput, int, TOutput] but usable in .NET 2.0. Only used to convert
/// arrays.
/// </summary>
internal delegate TOutput IndexedConverter<TInput, TOutput>(TInput element, int index);
/// <summary>
/// Converts the given array into a read-only list, applying the specified conversion to
/// each input element.
/// </summary>
internal static IList<TOutput> ConvertAndMakeReadOnly<TInput, TOutput>(IList<TInput> input,
IndexedConverter<TInput, TOutput> converter) {
TOutput[] array = new TOutput[input.Count];
for (int i = 0; i < array.Length; i++) {
array[i] = converter(input[i], i);
}
return Lists<TOutput>.AsReadOnly(array);
}
}
}

70
csharp/ProtocolBuffers/Descriptors/DescriptorValidationException.cs
View file

@ -1,70 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Thrown when building descriptors fails because the source DescriptorProtos
/// are not valid.
/// </summary>
public sealed class DescriptorValidationException : Exception {
private readonly String name;
private readonly IMessage proto;
private readonly string description;
/// <value>
/// The full name of the descriptor where the error occurred.
/// </value>
public String ProblemSymbolName {
get { return name; }
}
/// <value>
/// The protocol message representation of the invalid descriptor.
/// </value>
public IMessage ProblemProto {
get { return proto; }
}
/// <value>
/// A human-readable description of the error. (The Message property
/// is made up of the descriptor's name and this description.)
/// </value>
public string Description {
get { return description; }
}
internal DescriptorValidationException(IDescriptor problemDescriptor, string description) :
base(problemDescriptor.FullName + ": " + description) {
// Note that problemDescriptor may be partially uninitialized, so we
// don't want to expose it directly to the user. So, we only provide
// the name and the original proto.
name = problemDescriptor.FullName;
proto = problemDescriptor.Proto;
this.description = description;
}
internal DescriptorValidationException(IDescriptor problemDescriptor, string description, Exception cause) :
base(problemDescriptor.FullName + ": " + description, cause) {
name = problemDescriptor.FullName;
proto = problemDescriptor.Proto;
this.description = description;
}
}
}

76
csharp/ProtocolBuffers/Descriptors/EnumDescriptor.cs
View file

@ -1,76 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System.Collections.Generic;
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Descriptor for an enum type in a .proto file.
/// </summary>
public sealed class EnumDescriptor : IndexedDescriptorBase<EnumDescriptorProto, EnumOptions> {
private readonly MessageDescriptor containingType;
private readonly IList<EnumValueDescriptor> values;
internal EnumDescriptor(EnumDescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int index)
: base(proto, file, ComputeFullName(file, parent, proto.Name), index) {
containingType = parent;
if (proto.ValueCount == 0) {
// We cannot allow enums with no values because this would mean there
// would be no valid default value for fields of this type.
throw new DescriptorValidationException(this, "Enums must contain at least one value.");
}
values = DescriptorUtil.ConvertAndMakeReadOnly(proto.ValueList,
(value, i) => new EnumValueDescriptor(value, file, this, i));
File.DescriptorPool.AddSymbol(this);
}
/// <value>
/// If this is a nested type, get the outer descriptor, otherwise null.
/// </value>
public MessageDescriptor ContainingType {
get { return containingType; }
}
/// <value>
/// An unmodifiable list of defined value descriptors for this enum.
/// </value>
public IList<EnumValueDescriptor> Values {
get { return values; }
}
/// <summary>
/// Finds an enum value by number. If multiple enum values have the
/// same number, this returns the first defined value with that number.
/// </summary>
internal EnumValueDescriptor FindValueByNumber(int number) {
return File.DescriptorPool.FindEnumValueByNumber(this, number);
}
/// <summary>
/// Finds an enum value by name.
/// </summary>
/// <param name="name">The unqualified name of the value (e.g. "FOO").</param>
/// <returns>The value's descriptor, or null if not found.</returns>
internal EnumValueDescriptor FindValueByName(string name) {
return File.DescriptorPool.FindSymbol<EnumValueDescriptor>(FullName + "." + name);
}
}
}

43
csharp/ProtocolBuffers/Descriptors/EnumValueDescriptor.cs
View file

@ -1,43 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Descriptor for a single enum value within an enum in a .proto file.
/// </summary>
public sealed class EnumValueDescriptor : IndexedDescriptorBase<EnumValueDescriptorProto, EnumValueOptions> {
private readonly EnumDescriptor enumDescriptor;
internal EnumValueDescriptor(EnumValueDescriptorProto proto, FileDescriptor file,
EnumDescriptor parent, int index)
: base (proto, file, parent.FullName + "." + proto.Name, index) {
enumDescriptor = parent;
file.DescriptorPool.AddSymbol(this);
file.DescriptorPool.AddEnumValueByNumber(this);
}
public int Number {
get { return Proto.Number; }
}
public EnumDescriptor EnumDescriptor {
get { return enumDescriptor; }
}
}
}

437
csharp/ProtocolBuffers/Descriptors/FieldDescriptor.cs
View file

@ -1,437 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections.Generic;
using System.Reflection;
using Google.ProtocolBuffers.Collections;
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Descriptor for a field or extension within a message in a .proto file.
/// </summary>
public sealed class FieldDescriptor : IndexedDescriptorBase<FieldDescriptorProto, FieldOptions>, IComparable<FieldDescriptor> {
private readonly MessageDescriptor extensionScope;
private EnumDescriptor enumType;
private MessageDescriptor messageType;
private MessageDescriptor containingType;
private object defaultValue;
private FieldType fieldType;
private MappedType mappedType;
internal FieldDescriptor(FieldDescriptorProto proto, FileDescriptor file,
MessageDescriptor parent, int index, bool isExtension)
: base(proto, file, ComputeFullName(file, parent, proto.Name), index) {
if (proto.HasType) {
fieldType = GetFieldTypeFromProtoType(proto.Type);
mappedType = FieldTypeToMappedTypeMap[fieldType];
}
if (FieldNumber <= 0) {
throw new DescriptorValidationException(this,
"Field numbers must be positive integers.");
}
if (isExtension) {
if (!proto.HasExtendee) {
throw new DescriptorValidationException(this,
"FieldDescriptorProto.Extendee not set for extension field.");
}
containingType = null; // Will be filled in when cross-linking
if (parent != null) {
extensionScope = parent;
} else {
extensionScope = null;
}
} else {
if (proto.HasExtendee) {
throw new DescriptorValidationException(this,
"FieldDescriptorProto.Extendee set for non-extension field.");
}
containingType = parent;
extensionScope = null;
}
file.DescriptorPool.AddSymbol(this);
}
/// <summary>
/// Maps a field type as included in the .proto file to a FieldType.
/// </summary>
private static FieldType GetFieldTypeFromProtoType(FieldDescriptorProto.Types.Type type) {
switch (type) {
case FieldDescriptorProto.Types.Type.TYPE_DOUBLE: return FieldType.Double;
case FieldDescriptorProto.Types.Type.TYPE_FLOAT: return FieldType.Float;
case FieldDescriptorProto.Types.Type.TYPE_INT64: return FieldType.Int64;
case FieldDescriptorProto.Types.Type.TYPE_UINT64: return FieldType.UInt64;
case FieldDescriptorProto.Types.Type.TYPE_INT32: return FieldType.Int32;
case FieldDescriptorProto.Types.Type.TYPE_FIXED64: return FieldType.Fixed64;
case FieldDescriptorProto.Types.Type.TYPE_FIXED32: return FieldType.Fixed32;
case FieldDescriptorProto.Types.Type.TYPE_BOOL: return FieldType.Bool;
case FieldDescriptorProto.Types.Type.TYPE_STRING: return FieldType.String;
case FieldDescriptorProto.Types.Type.TYPE_GROUP: return FieldType.Group;
case FieldDescriptorProto.Types.Type.TYPE_MESSAGE: return FieldType.Message;
case FieldDescriptorProto.Types.Type.TYPE_BYTES: return FieldType.Bytes;
case FieldDescriptorProto.Types.Type.TYPE_UINT32: return FieldType.UInt32;
case FieldDescriptorProto.Types.Type.TYPE_ENUM: return FieldType.Enum;
case FieldDescriptorProto.Types.Type.TYPE_SFIXED32: return FieldType.SFixed32;
case FieldDescriptorProto.Types.Type.TYPE_SFIXED64: return FieldType.SFixed64;
case FieldDescriptorProto.Types.Type.TYPE_SINT32: return FieldType.SInt32;
case FieldDescriptorProto.Types.Type.TYPE_SINT64: return FieldType.SInt64;
default:
throw new ArgumentException("Invalid type specified");
}
}
/// <summary>
/// Returns the default value for a mapped type.
/// </summary>
private static object GetDefaultValueForMappedType(MappedType type) {
switch (type) {
case MappedType.Int32: return 0;
case MappedType.Int64: return (long) 0;
case MappedType.UInt32: return (uint) 0;
case MappedType.UInt64: return (ulong) 0;
case MappedType.Single: return (float) 0;
case MappedType.Double: return (double) 0;
case MappedType.Boolean: return false;
case MappedType.String: return "";
case MappedType.ByteString: return ByteString.Empty;
case MappedType.Message: return null;
case MappedType.Enum: return null;
default:
throw new ArgumentException("Invalid type specified");
}
}
public bool IsRequired {
get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_REQUIRED; }
}
public bool IsOptional {
get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_OPTIONAL; }
}
public bool IsRepeated {
get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_REPEATED; }
}
/// <valule>
/// Indicates whether or not the field had an explicitly-defined default value.
/// </value>
public bool HasDefaultValue {
get { return Proto.HasDefaultValue; }
}
/// <value>
/// The field's default value. Valid for all types except messages
/// and groups. For all other types, the object returned is of the
/// same class that would be returned by IMessage[this].
/// For repeated fields this will always be an empty immutable list compatible with IList[object].
/// For message fields it will always be null. For singular values, it will depend on the descriptor.
/// </value>
public object DefaultValue {
get {
if (MappedType == MappedType.Message) {
throw new InvalidOperationException("FieldDescriptor.DefaultValue called on an embedded message field.");
}
return defaultValue;
}
}
/// <value>
/// Indicates whether or not this field is an extension.
/// </value>
public bool IsExtension {
get { return Proto.HasExtendee; }
}
/*
* Get the field's containing type. For extensions, this is the type being
* extended, not the location where the extension was defined. See
* {@link #getExtensionScope()}.
*/
/// <summary>
/// Get the field's containing type. For extensions, this is the type being
/// extended, not the location where the extension was defined. See
/// <see cref="ExtensionScope" />.
/// </summary>
public MessageDescriptor ContainingType {
get { return containingType; }
}
/// <summary>
/// For extensions defined nested within message types, gets
/// the outer type. Not valid for non-extension fields.
/// </summary>
/// <example>
/// <code>
/// message Foo {
/// extensions 1000 to max;
/// }
/// extend Foo {
/// optional int32 baz = 1234;
/// }
/// message Bar {
/// extend Foo {
/// optional int32 qux = 4321;
/// }
/// }
/// </code>
/// The containing type for both <c>baz</c> and <c>qux</c> is <c>Foo</c>.
/// However, the extension scope for <c>baz</c> is <c>null</c> while
/// the extension scope for <c>qux</c> is <c>Bar</c>.
/// </example>
public MessageDescriptor ExtensionScope {
get {
if (!IsExtension) {
throw new InvalidOperationException("This field is not an extension.");
}
return extensionScope;
}
}
public MappedType MappedType {
get { return mappedType; }
}
public FieldType FieldType {
get { return fieldType; }
}
public int FieldNumber {
get { return Proto.Number; }
}
/// <summary>
/// Compares this descriptor with another one, ordering in "canonical" order
/// which simply means ascending order by field number. <paramref name="other"/>
/// must be a field of the same type, i.e. the <see cref="ContainingType"/> of
/// both fields must be the same.
/// </summary>
public int CompareTo(FieldDescriptor other) {
if (other.containingType != containingType) {
throw new ArgumentException("FieldDescriptors can only be compared to other FieldDescriptors " +
"for fields of the same message type.");
}
return FieldNumber - other.FieldNumber;
}
/// <summary>
/// For enum fields, returns the field's type.
/// </summary>
public EnumDescriptor EnumType {
get {
if (MappedType != MappedType.Enum) {
throw new InvalidOperationException("EnumType is only valid for enum fields.");
}
return enumType;
}
}
/// <summary>
/// For embedded message and group fields, returns the field's type.
/// </summary>
public MessageDescriptor MessageType {
get {
if (MappedType != MappedType.Message) {
throw new InvalidOperationException("MessageType is only valid for enum fields.");
}
return messageType;
}
}
/// <summary>
/// Immutable mapping from field type to mapped type. Built using the attributes on
/// FieldType values.
/// </summary>
public static readonly IDictionary<FieldType, MappedType> FieldTypeToMappedTypeMap = MapFieldTypes();
private static IDictionary<FieldType, MappedType> MapFieldTypes() {
var map = new Dictionary<FieldType, MappedType>();
foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public)) {
FieldType fieldType = (FieldType)field.GetValue(null);
FieldMappingAttribute mapping = (FieldMappingAttribute)field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0];
map[fieldType] = mapping.MappedType;
}
return Dictionaries.AsReadOnly(map);
}
/// <summary>
/// Look up and cross-link all field types etc.
/// </summary>
internal void CrossLink() {
if (Proto.HasExtendee) {
IDescriptor extendee = File.DescriptorPool.LookupSymbol(Proto.Extendee, this);
if (!(extendee is MessageDescriptor)) {
throw new DescriptorValidationException(this, "\"" + Proto.Extendee + "\" is not a message type.");
}
containingType = (MessageDescriptor) extendee;
if (!containingType.IsExtensionNumber(FieldNumber)) {
throw new DescriptorValidationException(this,
"\"" + containingType.FullName + "\" does not declare " + FieldNumber + " as an extension number.");
}
}
if (Proto.HasTypeName) {
IDescriptor typeDescriptor =
File.DescriptorPool.LookupSymbol(Proto.TypeName, this);
if (!Proto.HasType) {
// Choose field type based on symbol.
if (typeDescriptor is MessageDescriptor) {
fieldType = FieldType.Message;
mappedType = MappedType.Message;
} else if (typeDescriptor is EnumDescriptor) {
fieldType = FieldType.Enum;
mappedType = MappedType.Enum;
} else {
throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not a type.");
}
}
if (MappedType == MappedType.Message) {
if (!(typeDescriptor is MessageDescriptor)) {
throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not a message type.");
}
messageType = (MessageDescriptor) typeDescriptor;
if (Proto.HasDefaultValue) {
throw new DescriptorValidationException(this, "Messages can't have default values.");
}
} else if (MappedType == Descriptors.MappedType.Enum) {
if (!(typeDescriptor is EnumDescriptor)) {
throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not an enum type.");
}
enumType = (EnumDescriptor)typeDescriptor;
} else {
throw new DescriptorValidationException(this, "Field with primitive type has type_name.");
}
} else {
if (MappedType == MappedType.Message || MappedType == MappedType.Enum) {
throw new DescriptorValidationException(this, "Field with message or enum type missing type_name.");
}
}
// We don't attempt to parse the default value until here because for
// enums we need the enum type's descriptor.
if (Proto.HasDefaultValue) {
if (IsRepeated) {
throw new DescriptorValidationException(this, "Repeated fields cannot have default values.");
}
try {
switch (FieldType) {
case FieldType.Int32:
case FieldType.SInt32:
case FieldType.SFixed32:
defaultValue = TextFormat.ParseInt32(Proto.DefaultValue);
break;
case FieldType.UInt32:
case FieldType.Fixed32:
defaultValue = TextFormat.ParseUInt32(Proto.DefaultValue);
break;
case FieldType.Int64:
case FieldType.SInt64:
case FieldType.SFixed64:
defaultValue = TextFormat.ParseInt64(Proto.DefaultValue);
break;
case FieldType.UInt64:
case FieldType.Fixed64:
defaultValue = TextFormat.ParseUInt64(Proto.DefaultValue);
break;
case FieldType.Float:
defaultValue = float.Parse(Proto.DefaultValue);
break;
case FieldType.Double:
defaultValue = double.Parse(Proto.DefaultValue);
break;
case FieldType.Bool:
if (Proto.DefaultValue == "true") {
defaultValue = true;
} else if (Proto.DefaultValue == "false") {
defaultValue = false;
} else {
throw new FormatException("Boolean values must be \"true\" or \"false\"");
}
break;
case FieldType.String:
defaultValue = Proto.DefaultValue;
break;
case FieldType.Bytes:
try {
defaultValue = TextFormat.UnescapeBytes(Proto.DefaultValue);
} catch (FormatException e) {
throw new DescriptorValidationException(this, "Couldn't parse default value: " + e.Message);
}
break;
case FieldType.Enum:
defaultValue = enumType.FindValueByName(Proto.DefaultValue);
if (defaultValue == null) {
throw new DescriptorValidationException(this, "Unknown enum default value: \"" + Proto.DefaultValue + "\"");
}
break;
case FieldType.Message:
case FieldType.Group:
throw new DescriptorValidationException(this, "Message type had default value.");
}
} catch (FormatException e) {
DescriptorValidationException validationException =
new DescriptorValidationException(this, "Could not parse default value: \"" + Proto.DefaultValue + "\"", e);
throw validationException;
}
} else {
// Determine the default default for this field.
if (IsRepeated) {
defaultValue = Lists<object>.Empty;
} else {
switch (MappedType) {
case MappedType.Enum:
// We guarantee elsewhere that an enum type always has at least
// one possible value.
defaultValue = enumType.Values[0];
break;
case MappedType.Message:
defaultValue = null;
break;
default:
defaultValue = GetDefaultValueForMappedType(MappedType);
break;
}
}
}
if (!IsExtension) {
File.DescriptorPool.AddFieldByNumber(this);
}
if (containingType != null && containingType.Options.MessageSetWireFormat) {
if (IsExtension) {
if (!IsOptional || FieldType != FieldType.Message) {
throw new DescriptorValidationException(this, "Extensions of MessageSets must be optional messages.");
}
} else {
throw new DescriptorValidationException(this, "MessageSets cannot have fields, only extensions.");
}
}
}
}
}

34
csharp/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs
View file

@ -1,34 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Defined specifically for the <see cref="FieldType" /> enumeration,
/// this allows each field type to specify the mapped type and wire type.
/// </summary>
[AttributeUsage(AttributeTargets.Field)]
internal sealed class FieldMappingAttribute : Attribute {
internal FieldMappingAttribute(MappedType mappedType, WireFormat.WireType wireType) {
MappedType = mappedType;
WireType = wireType;
}
internal MappedType MappedType { get; private set; }
internal WireFormat.WireType WireType { get; private set; }
}
}

42
csharp/ProtocolBuffers/Descriptors/FieldType.cs
View file

@ -1,42 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Enumeration of all the possible field types. The odd formatting is to make it very clear
/// which attribute applies to which value, while maintaining a compact format.
/// </summary>
public enum FieldType {
[FieldMapping(MappedType.Double, WireFormat.WireType.Fixed64)] Double,
[FieldMapping(MappedType.Single, WireFormat.WireType.Fixed32)] Float,
[FieldMapping(MappedType.Int64, WireFormat.WireType.Varint)] Int64,
[FieldMapping(MappedType.UInt64, WireFormat.WireType.Varint)] UInt64,
[FieldMapping(MappedType.Int32, WireFormat.WireType.Varint)] Int32,
[FieldMapping(MappedType.UInt64, WireFormat.WireType.Fixed64)] Fixed64,
[FieldMapping(MappedType.UInt32, WireFormat.WireType.Fixed32)] Fixed32,
[FieldMapping(MappedType.Boolean, WireFormat.WireType.Varint)] Bool,
[FieldMapping(MappedType.String, WireFormat.WireType.LengthDelimited)] String,
[FieldMapping(MappedType.Message, WireFormat.WireType.StartGroup)] Group,
[FieldMapping(MappedType.Message, WireFormat.WireType.LengthDelimited)] Message,
[FieldMapping(MappedType.ByteString, WireFormat.WireType.LengthDelimited)] Bytes,
[FieldMapping(MappedType.UInt32, WireFormat.WireType.Varint)] UInt32,
[FieldMapping(MappedType.Int32, WireFormat.WireType.Fixed32)] SFixed32,
[FieldMapping(MappedType.Int64, WireFormat.WireType.Fixed64)] SFixed64,
[FieldMapping(MappedType.Int32, WireFormat.WireType.Varint)] SInt32,
[FieldMapping(MappedType.Int64, WireFormat.WireType.Varint)] SInt64,
[FieldMapping(MappedType.Enum, WireFormat.WireType.Varint)] Enum
}
}

246
csharp/ProtocolBuffers/Descriptors/FileDescriptor.cs
View file

@ -1,246 +0,0 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.
// http://code.google.com/p/protobuf/
//
// 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.
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using Google.ProtocolBuffers.DescriptorProtos;
namespace Google.ProtocolBuffers.Descriptors {
/// <summary>
/// Describes a .proto file, including everything defined within.
/// IDescriptor is implemented such that the File property returns this descriptor,
/// and the FullName is the same as the Name.
/// </summary>
public sealed class FileDescriptor : IDescriptor<FileDescriptorProto> {
private readonly FileDescriptorProto proto;
private readonly IList<MessageDescriptor> messageTypes;
private readonly IList<EnumDescriptor> enumTypes;
private readonly IList<ServiceDescriptor> services;
private readonly IList<FieldDescriptor> extensions;
private readonly IList<FileDescriptor> dependencies;
private readonly DescriptorPool pool;
private FileDescriptor(FileDescriptorProto proto, FileDescriptor[] dependencies, DescriptorPool pool) {
this.pool = pool;
this.proto = proto;
this.dependencies = new ReadOnlyCollection<FileDescriptor>((FileDescriptor[]) dependencies.Clone());
pool.AddPackage(Package, this);
messageTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.MessageTypeList,
(message, index) => new MessageDescriptor(message, this, null, index));
enumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumTypeList,
(enumType, index) => new EnumDescriptor(enumType, this, null, index));
services = DescriptorUtil.ConvertAndMakeReadOnly(proto.ServiceList,
(service, index) => new ServiceDescriptor(service, this, index));
extensions = DescriptorUtil.ConvertAndMakeReadOnly(proto.ExtensionList,
(field, index) => new FieldDescriptor(field, this, null, index, true));
}
/// <value>
/// The descriptor in its protocol message representation.
/// </value>
public FileDescriptorProto Proto {
get { return proto; }
}
/// <value>
/// The <see cref="FileOptions" /> defined in <c>descriptor.proto</c>.
/// </value>
public FileOptions Options {
get { return proto.Options; }
}
/// <value>
/// The file name.
/// </value>
public string Name {
get { return proto.Name; }
}
/// <summary>
/// The package as declared in the .proto file. This may or may not
/// be equivalent to the .NET namespace of the generated classes.
/// </summary>
public string Package {
get { return proto.Package; }
}
/// <value>
/// Unmodifiable list of top-level message types declared in this file.
/// </value>
public IList<MessageDescriptor> MessageTypes {
get { return messageTypes; }
}
/// <value>
/// Unmodifiable list of top-level enum types declared in this file.
/// </value>
public IList<EnumDescriptor> EnumTypes {
get { return enumTypes; }
}
/// <value>
/// Unmodifiable list of top-level services declared in this file.
/// </value>
public IList<ServiceDescriptor> Services {
get { return services; }
}
/// <value>
/// Unmodifiable list of top-level extensions declared in this file.
/// </value>
public IList<FieldDescriptor> Extensions {
get { return extensions; }
}
/// <value>
/// Unmodifiable list of this file's dependencies (imports).
/// </value>
public IList<FileDescriptor> Dependencies {
get { return dependencies; }
}
/// <value>
/// Implementation of IDescriptor.FullName - just returns the same as Name.
/// </value>
string IDescriptor.FullName {
get { return Name; }
}
/// <value>
/// Implementation of IDescriptor.File - just returns this descriptor.
/// </value>
FileDescriptor IDescriptor.File {
get { return this; }
}
/// <value>
/// Protocol buffer describing this descriptor.
/// </value>
IMessage IDescriptor.Proto {
get { return Proto; }
}
/// <value>
/// Pool containing symbol descriptors.
/// </value>
internal DescriptorPool DescriptorPool {
get { return pool; }
}
/// <summary>
/// Finds a type (message, enum, service or extension) in the file by name. Does not find nested types.
/// </summary>
/// <param name="name">The unqualified type name to look for.</param>
/// <typeparam name="T">The type of descriptor to look for (or ITypeDescriptor for any)</typeparam>
/// <returns>The type's descriptor, or null if not found.</returns>
public T FindTypeByName<T>(String name)
where T : class, IDescriptor {
// Don't allow looking up nested types. This will make optimization
// easier later.
if (name.IndexOf('.') != -1) {
return null;
}
if (Package.Length > 0) {
name = Package + "." + name;
}
T result = pool.FindSymbol<T>(name);
if (result != null && result.File == this) {
return result;
}
return null;
}
/// <summary>
/// Builds a FileDescriptor from its protocol buffer representation.
/// </summary>
/// <param name="proto">The protocol message form of the FileDescriptor.</param>
/// <param name="dependencies">FileDescriptors corresponding to all of the
/// file's dependencies, in the exact order listed in the .proto file. May be null,
/// in which case it is treated as an empty array.</param>
/// <exception cref="DescriptorValidationException">If <paramref name="proto"/> is not
/// a valid descriptor. This can occur for a number of reasons, such as a field
/// having an undefined type or because two messages were defined with the same name.</exception>
public static FileDescriptor BuildFrom(FileDescriptorProto proto, FileDescriptor[] dependencies) {
// Building descriptors involves two steps: translating and linking.
// In the translation step (implemented by FileDescriptor's
// constructor), we build an object tree mirroring the
// FileDescriptorProto's tree and put all of the descriptors into the
// DescriptorPool's lookup tables. In the linking step, we look up all
// type references in the DescriptorPool, so that, for example, a
// FieldDescriptor for an embedded message contains a pointer directly
// to the Descriptor for that message's type. We also detect undefined
// types in the linking step.
if (dependencies == null) {
dependencies = new FileDescriptor[0];
}
DescriptorPool pool = new DescriptorPool(dependencies);
FileDescriptor result = new FileDescriptor(proto, dependencies, pool);
if (dependencies.Length != proto.DependencyCount) {
throw new DescriptorValidationException(result,
"Dependencies passed to FileDescriptor.BuildFrom() don't match " +
"those listed in the FileDescriptorProto.");
}
for (int i = 0; i < proto.DependencyCount; i++) {
if (dependencies[i].Name != proto.DependencyList[i]) {
/*throw new DescriptorValidationException(result,
"Dependencies passed to FileDescriptor.BuildFrom() don't match " +
"those listed in the FileDescriptorProto.");*/
}
}
result.CrossLink();
return result;
}
private void CrossLink() {
foreach (MessageDescriptor message in messageTypes) {
message.CrossLink();
}
foreach (ServiceDescriptor service in services) {
service.CrossLink();
}
foreach (FieldDescriptor extension in extensions) {
extension.CrossLink();
}
foreach (MessageDescriptor message in messageTypes) {
message.CheckRequiredFields();
}
}
/// <summary>
/// This method is to be called by generated code only. It is equivalent
/// to BuilderFrom except that the FileDescriptorProto is encoded in
/// protocol buffer wire format.
/// </summary>
public static FileDescriptor InternalBuildGeneratedFileFrom(byte[] descriptorData,
FileDescriptor[] dependencies) {
FileDescriptorProto proto = FileDescriptorProto.ParseFrom(descriptorData);
return BuildFrom(proto, dependencies);
}
}
}

Some files were not shown because too many files have changed in this diff Show more